1 /*

     2  * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 #include <stdio.h>

    27 #include <stdlib.h>

    28 #include <memory.h>

    29 #include "sun_java2d_cmm_lcms_LCMS.h"

    30 #include "jni_util.h"

    31 #include "Trace.h"

    32 #include "Disposer.h"

    33 #include <lcms2.h>

    34 #include "jlong.h"

    35 

    36 

    37 #define ALIGNLONG(x) (((x)+3) & ~(3))         // Aligns to DWORD boundary

    38 

    39 #ifdef USE_BIG_ENDIAN

    40 #define AdjustEndianess32(a)

    41 #else

    42 

    43 static

    44 void AdjustEndianess32(cmsUInt8Number *pByte)

    45 {

    46     cmsUInt8Number temp1;

    47     cmsUInt8Number temp2;

    48 

    49     temp1 = *pByte++;

    50     temp2 = *pByte++;

    51     *(pByte-1) = *pByte;

    52     *pByte++ = temp2;

    53     *(pByte-3) = *pByte;

    54     *pByte = temp1;

    55 }

    56 

    57 #endif

    58 

    59 // Transports to properly encoded values - note that icc profiles does use

    60 // big endian notation.

    61 

    62 static

    63 cmsInt32Number TransportValue32(cmsInt32Number Value)

    64 {

    65     cmsInt32Number Temp = Value;

    66 

    67     AdjustEndianess32((cmsUInt8Number*) &Temp);

    68     return Temp;

    69 }

    70 

    71 #define SigMake(a,b,c,d) \

    72                     ( ( ((int) ((unsigned char) (a))) << 24) | \

    73                       ( ((int) ((unsigned char) (b))) << 16) | \

    74                       ( ((int) ((unsigned char) (c))) <<  8) | \

    75                           (int) ((unsigned char) (d)))

    76 

    77 #define TagIdConst(a, b, c, d) \

    78                 ((int) SigMake ((a), (b), (c), (d)))

    79 

    80 #define SigHead TagIdConst('h','e','a','d')

    81 

    82 #define DT_BYTE     0

    83 #define DT_SHORT    1

    84 #define DT_INT      2

    85 #define DT_DOUBLE   3

    86 

    87 /* Default temp profile list size */

    88 #define DF_ICC_BUF_SIZE 32

    89 

    90 #define ERR_MSG_SIZE 256

    91 

    92 #ifdef _MSC_VER

    93 # ifndef snprintf

    94 #       define snprintf  _snprintf

    95 # endif

    96 #endif

    97 

    98 typedef struct lcmsProfile_s {

    99     cmsHPROFILE pf;

   100 } lcmsProfile_t, *lcmsProfile_p;

   101 

   102 typedef union {

   103     cmsTagSignature cms;

   104     jint j;

   105 } TagSignature_t, *TagSignature_p;

   106 

   107 static jfieldID Trans_renderType_fID;

   108 static jfieldID Trans_ID_fID;

   109 static jfieldID IL_isIntPacked_fID;

   110 static jfieldID IL_dataType_fID;

   111 static jfieldID IL_pixelType_fID;

   112 static jfieldID IL_dataArray_fID;

   113 static jfieldID IL_offset_fID;

   114 static jfieldID IL_nextRowOffset_fID;

   115 static jfieldID IL_width_fID;

   116 static jfieldID IL_height_fID;

   117 static jfieldID IL_imageAtOnce_fID;

   118 

   119 JavaVM *javaVM;

   120 

   121 void errorHandler(cmsContext ContextID, cmsUInt32Number errorCode,

   122                   const char *errorText) {

   123     JNIEnv *env;

   124     char errMsg[ERR_MSG_SIZE];

   125 

   126     int count = snprintf(errMsg, ERR_MSG_SIZE,

   127                           "LCMS error %d: %s", errorCode, errorText);

   128     if (count < 0 || count >= ERR_MSG_SIZE) {

   129         count = ERR_MSG_SIZE - 1;

   130     }

   131     errMsg[count] = 0;

   132 

   133     (*javaVM)->AttachCurrentThread(javaVM, (void**)&env, NULL);

   134     JNU_ThrowByName(env, "java/awt/color/CMMException", errMsg);

   135 }

   136 

   137 JNIEXPORT jint JNICALL DEF_JNI_OnLoad(JavaVM *jvm, void *reserved) {

   138     javaVM = jvm;

   139 

   140     cmsSetLogErrorHandler(errorHandler);

   141     return JNI_VERSION_1_6;

   142 }

   143 

   144 void LCMS_freeProfile(JNIEnv *env, jlong ptr) {

   145     lcmsProfile_p p = (lcmsProfile_p)jlong_to_ptr(ptr);

   146 

   147     if (p != NULL) {

   148         if (p->pf != NULL) {

   149             cmsCloseProfile(p->pf);

   150         }

   151         free(p);

   152     }

   153 }

   154 

   155 void LCMS_freeTransform(JNIEnv *env, jlong ID)

   156 {

   157     cmsHTRANSFORM sTrans = jlong_to_ptr(ID);

   158     /* Passed ID is always valid native ref so there is no check for zero */

   159     cmsDeleteTransform(sTrans);

   160 }

   161 

   162 /*

   163  * Class:     sun_java2d_cmm_lcms_LCMS

   164  * Method:    createNativeTransform

   165  * Signature: ([JI)J

   166  */

   167 JNIEXPORT jlong JNICALL Java_sun_java2d_cmm_lcms_LCMS_createNativeTransform

   168   (JNIEnv *env, jclass cls, jlongArray profileIDs, jint renderType,

   169    jint inFormatter, jboolean isInIntPacked,

   170    jint outFormatter, jboolean isOutIntPacked, jobject disposerRef)

   171 {

   172     cmsHPROFILE _iccArray[DF_ICC_BUF_SIZE];

   173     cmsHPROFILE *iccArray = &_iccArray[0];

   174     cmsHTRANSFORM sTrans = NULL;

   175     int i, j, size;

   176     jlong* ids;

   177 

   178     size = (*env)->GetArrayLength (env, profileIDs);

   179     ids = (*env)->GetLongArrayElements(env, profileIDs, 0);

   180     if (ids == NULL) {

   181         // An exception should have already been thrown.

   182         return 0L;

   183     }

   184 

   185 #ifdef _LITTLE_ENDIAN

   186     /* Reversing data packed into int for LE archs */

   187     if (isInIntPacked) {

   188         inFormatter ^= DOSWAP_SH(1);

   189     }

   190     if (isOutIntPacked) {

   191         outFormatter ^= DOSWAP_SH(1);

   192     }

   193 #endif

   194 

   195     if (DF_ICC_BUF_SIZE < size*2) {

   196         iccArray = (cmsHPROFILE*) malloc(

   197             size*2*sizeof(cmsHPROFILE));

   198         if (iccArray == NULL) {

   199             (*env)->ReleaseLongArrayElements(env, profileIDs, ids, 0);

   200 

   201             J2dRlsTraceLn(J2D_TRACE_ERROR, "getXForm: iccArray == NULL");

   202             return 0L;

   203         }

   204     }

   205 

   206     j = 0;

   207     for (i = 0; i < size; i++) {

   208         cmsColorSpaceSignature cs;

   209         lcmsProfile_p profilePtr = (lcmsProfile_p)jlong_to_ptr(ids[i]);

   210         cmsHPROFILE icc = profilePtr->pf;

   211 

   212         iccArray[j++] = icc;

   213 

   214         /* Middle non-abstract profiles should be doubled before passing to

   215          * the cmsCreateMultiprofileTransform function

   216          */

   217 

   218         cs = cmsGetColorSpace(icc);

   219         if (size > 2 && i != 0 && i != size - 1 &&

   220             cs != cmsSigXYZData && cs != cmsSigLabData)

   221         {

   222             iccArray[j++] = icc;

   223         }

   224     }

   225 

   226     sTrans = cmsCreateMultiprofileTransform(iccArray, j,

   227         inFormatter, outFormatter, renderType, 0);

   228 

   229     (*env)->ReleaseLongArrayElements(env, profileIDs, ids, 0);

   230 

   231     if (sTrans == NULL) {

   232         J2dRlsTraceLn(J2D_TRACE_ERROR, "LCMS_createNativeTransform: "

   233                                        "sTrans == NULL");

   234         if ((*env)->ExceptionOccurred(env) == NULL) {

   235             JNU_ThrowByName(env, "java/awt/color/CMMException",

   236                             "Cannot get color transform");

   237         }

   238     } else {

   239         Disposer_AddRecord(env, disposerRef, LCMS_freeTransform, ptr_to_jlong(sTrans));

   240     }

   241 

   242     if (iccArray != &_iccArray[0]) {

   243         free(iccArray);

   244     }

   245     return ptr_to_jlong(sTrans);

   246 }

   247 

   248 

   249 /*

   250  * Class:     sun_java2d_cmm_lcms_LCMS

   251  * Method:    loadProfile

   252  * Signature: ([B,Lsun/java2d/cmm/lcms/LCMSProfile;)V

   253  */

   254 JNIEXPORT jlong JNICALL Java_sun_java2d_cmm_lcms_LCMS_loadProfileNative

   255   (JNIEnv *env, jobject obj, jbyteArray data, jobject disposerRef)

   256 {

   257     jbyte* dataArray;

   258     jint dataSize;

   259     lcmsProfile_p sProf = NULL;

   260     cmsHPROFILE pf;

   261 

   262     if (JNU_IsNull(env, data)) {

   263         JNU_ThrowIllegalArgumentException(env, "Invalid profile data");

   264         return 0L;

   265     }

   266 

   267     dataArray = (*env)->GetByteArrayElements (env, data, 0);

   268     if (dataArray == NULL) {

   269         // An exception should have already been thrown.

   270         return 0L;

   271     }

   272 

   273     dataSize = (*env)->GetArrayLength (env, data);

   274 

   275     pf = cmsOpenProfileFromMem((const void *)dataArray,

   276                                      (cmsUInt32Number) dataSize);

   277 

   278     (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);

   279 

   280     if (pf == NULL) {

   281         JNU_ThrowIllegalArgumentException(env, "Invalid profile data");

   282     } else {

   283         /* Sanity check: try to save the profile in order

   284          * to force basic validation.

   285          */

   286         cmsUInt32Number pfSize = 0;

   287         if (!cmsSaveProfileToMem(pf, NULL, &pfSize) ||

   288             pfSize < sizeof(cmsICCHeader))

   289         {

   290             JNU_ThrowIllegalArgumentException(env, "Invalid profile data");

   291 

   292             cmsCloseProfile(pf);

   293             pf = NULL;

   294         }

   295     }

   296 

   297     if (pf != NULL) {

   298         // create profile holder

   299         sProf = (lcmsProfile_p)malloc(sizeof(lcmsProfile_t));

   300         if (sProf != NULL) {

   301             // register the disposer record

   302             sProf->pf = pf;

   303             Disposer_AddRecord(env, disposerRef, LCMS_freeProfile, ptr_to_jlong(sProf));

   304         } else {

   305             cmsCloseProfile(pf);

   306         }

   307     }

   308 

   309     return ptr_to_jlong(sProf);

   310 }

   311 

   312 /*

   313  * Class:     sun_java2d_cmm_lcms_LCMS

   314  * Method:    getProfileSizeNative

   315  * Signature: (J)I

   316  */

   317 JNIEXPORT jint JNICALL Java_sun_java2d_cmm_lcms_LCMS_getProfileSizeNative

   318   (JNIEnv *env, jobject obj, jlong id)

   319 {

   320     lcmsProfile_p sProf = (lcmsProfile_p)jlong_to_ptr(id);

   321     cmsUInt32Number pfSize = 0;

   322 

   323     if (cmsSaveProfileToMem(sProf->pf, NULL, &pfSize) && ((jint)pfSize > 0)) {

   324         return (jint)pfSize;

   325     } else {

   326       JNU_ThrowByName(env, "java/awt/color/CMMException",

   327                       "Can not access specified profile.");

   328         return -1;

   329     }

   330 }

   331 

   332 /*

   333  * Class:     sun_java2d_cmm_lcms_LCMS

   334  * Method:    getProfileDataNative

   335  * Signature: (J[B)V

   336  */

   337 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_getProfileDataNative

   338   (JNIEnv *env, jobject obj, jlong id, jbyteArray data)

   339 {

   340     lcmsProfile_p sProf = (lcmsProfile_p)jlong_to_ptr(id);

   341     jint size;

   342     jbyte* dataArray;

   343     cmsUInt32Number pfSize = 0;

   344     cmsBool status;

   345 

   346     // determine actual profile size

   347     if (!cmsSaveProfileToMem(sProf->pf, NULL, &pfSize)) {

   348         JNU_ThrowByName(env, "java/awt/color/CMMException",

   349                         "Can not access specified profile.");

   350         return;

   351     }

   352 

   353     // verify java buffer capacity

   354     size = (*env)->GetArrayLength(env, data);

   355     if (0 >= size || pfSize > (cmsUInt32Number)size) {

   356         JNU_ThrowByName(env, "java/awt/color/CMMException",

   357                         "Insufficient buffer capacity.");

   358         return;

   359     }

   360 

   361     dataArray = (*env)->GetByteArrayElements (env, data, 0);

   362     if (dataArray == NULL) {

   363         // An exception should have already been thrown.

   364         return;

   365     }

   366 

   367     status = cmsSaveProfileToMem(sProf->pf, dataArray, &pfSize);

   368 

   369     (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);

   370 

   371     if (!status) {

   372         JNU_ThrowByName(env, "java/awt/color/CMMException",

   373                         "Can not access specified profile.");

   374         return;

   375     }

   376 }

   377 

   378 /* Get profile header info */

   379 static cmsBool _getHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize);

   380 static cmsBool _setHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize);

   381 static cmsHPROFILE _writeCookedTag(cmsHPROFILE pfTarget, cmsTagSignature sig, jbyte *pData, jint size);

   382 

   383 

   384 /*

   385  * Class:     sun_java2d_cmm_lcms_LCMS

   386  * Method:    getTagData

   387  * Signature: (JI[B)V

   388  */

   389 JNIEXPORT jbyteArray JNICALL Java_sun_java2d_cmm_lcms_LCMS_getTagNative

   390   (JNIEnv *env, jobject obj, jlong id, jint tagSig)

   391 {

   392     lcmsProfile_p sProf = (lcmsProfile_p)jlong_to_ptr(id);

   393     TagSignature_t sig;

   394     cmsInt32Number tagSize;

   395 

   396     jbyte* dataArray = NULL;

   397     jbyteArray data = NULL;

   398 

   399     jint bufSize;

   400 

   401     sig.j = tagSig;

   402 

   403     if (tagSig == SigHead) {

   404         cmsBool status;

   405 

   406         // allocate java array

   407         bufSize = sizeof(cmsICCHeader);

   408         data = (*env)->NewByteArray(env, bufSize);

   409 

   410         if (data == NULL) {

   411             // An exception should have already been thrown.

   412             return NULL;

   413         }

   414 

   415         dataArray = (*env)->GetByteArrayElements (env, data, 0);

   416 

   417         if (dataArray == NULL) {

   418             // An exception should have already been thrown.

   419             return NULL;

   420         }

   421 

   422         status = _getHeaderInfo(sProf->pf, dataArray, bufSize);

   423 

   424         (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);

   425 

   426         if (!status) {

   427             JNU_ThrowByName(env, "java/awt/color/CMMException",

   428                             "ICC Profile header not found");

   429             return NULL;

   430         }

   431 

   432         return data;

   433     }

   434 

   435     if (cmsIsTag(sProf->pf, sig.cms)) {

   436         tagSize = cmsReadRawTag(sProf->pf, sig.cms, NULL, 0);

   437     } else {

   438         JNU_ThrowByName(env, "java/awt/color/CMMException",

   439                         "ICC profile tag not found");

   440         return NULL;

   441     }

   442 

   443     // allocate java array

   444     data = (*env)->NewByteArray(env, tagSize);

   445     if (data == NULL) {

   446         // An exception should have already been thrown.

   447         return NULL;

   448     }

   449 

   450     dataArray = (*env)->GetByteArrayElements (env, data, 0);

   451 

   452     if (dataArray == NULL) {

   453         // An exception should have already been thrown.

   454         return NULL;

   455     }

   456 

   457     bufSize = cmsReadRawTag(sProf->pf, sig.cms, dataArray, tagSize);

   458 

   459     (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);

   460 

   461     if (bufSize != tagSize) {

   462         JNU_ThrowByName(env, "java/awt/color/CMMException",

   463                         "Can not get tag data.");

   464         return NULL;

   465     }

   466     return data;

   467 }

   468 

   469 /*

   470  * Class:     sun_java2d_cmm_lcms_LCMS

   471  * Method:    setTagData

   472  * Signature: (JI[B)V

   473  */

   474 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_setTagDataNative

   475   (JNIEnv *env, jobject obj, jlong id, jint tagSig, jbyteArray data)

   476 {

   477     lcmsProfile_p sProf = (lcmsProfile_p)jlong_to_ptr(id);

   478     cmsHPROFILE pfReplace = NULL;

   479 

   480     TagSignature_t sig;

   481     cmsBool status = FALSE;

   482     jbyte* dataArray;

   483     int tagSize;

   484 

   485     sig.j = tagSig;

   486 

   487     if (JNU_IsNull(env, data)) {

   488         JNU_ThrowIllegalArgumentException(env, "Can not write tag data.");

   489         return;

   490     }

   491 

   492     tagSize =(*env)->GetArrayLength(env, data);

   493 

   494     dataArray = (*env)->GetByteArrayElements(env, data, 0);

   495 

   496     if (dataArray == NULL) {

   497         // An exception should have already been thrown.

   498         return;

   499     }

   500 

   501     if (tagSig == SigHead) {

   502         status  = _setHeaderInfo(sProf->pf, dataArray, tagSize);

   503     } else {

   504         /*

   505         * New strategy for generic tags: create a place holder,

   506         * dump all existing tags there, dump externally supplied

   507         * tag, and return the new profile to the java.

   508         */

   509         pfReplace = _writeCookedTag(sProf->pf, sig.cms, dataArray, tagSize);

   510         status = (pfReplace != NULL);

   511     }

   512 

   513     (*env)->ReleaseByteArrayElements(env, data, dataArray, 0);

   514 

   515     if (!status) {

   516         JNU_ThrowIllegalArgumentException(env, "Can not write tag data.");

   517     } else if (pfReplace != NULL) {

   518         cmsCloseProfile(sProf->pf);

   519         sProf->pf = pfReplace;

   520     }

   521 }

   522 

   523 void* getILData (JNIEnv *env, jobject img, jint* pDataType,

   524                  jobject* pDataObject) {

   525     void* result = NULL;

   526     *pDataType = (*env)->GetIntField (env, img, IL_dataType_fID);

   527     *pDataObject = (*env)->GetObjectField(env, img, IL_dataArray_fID);

   528     switch (*pDataType) {

   529         case DT_BYTE:

   530             result = (*env)->GetByteArrayElements (env, *pDataObject, 0);

   531             break;

   532         case DT_SHORT:

   533             result = (*env)->GetShortArrayElements (env, *pDataObject, 0);

   534             break;

   535         case DT_INT:

   536             result = (*env)->GetIntArrayElements (env, *pDataObject, 0);

   537             break;

   538         case DT_DOUBLE:

   539             result = (*env)->GetDoubleArrayElements (env, *pDataObject, 0);

   540             break;

   541     }

   542 

   543     return result;

   544 }

   545 

   546 void releaseILData (JNIEnv *env, void* pData, jint dataType,

   547                     jobject dataObject) {

   548     switch (dataType) {

   549         case DT_BYTE:

   550             (*env)->ReleaseByteArrayElements(env,dataObject,(jbyte*)pData,0);

   551             break;

   552         case DT_SHORT:

   553             (*env)->ReleaseShortArrayElements(env,dataObject,(jshort*)pData, 0);

   554             break;

   555         case DT_INT:

   556             (*env)->ReleaseIntArrayElements(env,dataObject,(jint*)pData,0);

   557             break;

   558         case DT_DOUBLE:

   559             (*env)->ReleaseDoubleArrayElements(env,dataObject,(jdouble*)pData,

   560                                                0);

   561             break;

   562     }

   563 }

   564 

   565 /*

   566  * Class:     sun_java2d_cmm_lcms_LCMS

   567  * Method:    colorConvert

   568  * Signature: (Lsun/java2d/cmm/lcms/LCMSTransform;Lsun/java2d/cmm/lcms/LCMSImageLayout;Lsun/java2d/cmm/lcms/LCMSImageLayout;)V

   569  */

   570 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_colorConvert

   571   (JNIEnv *env, jclass obj, jobject trans, jobject src, jobject dst)

   572 {

   573     cmsHTRANSFORM sTrans = NULL;

   574     int srcDType, dstDType;

   575     int srcOffset, srcNextRowOffset, dstOffset, dstNextRowOffset;

   576     int width, height, i;

   577     void* inputBuffer;

   578     void* outputBuffer;

   579     char* inputRow;

   580     char* outputRow;

   581     jobject srcData, dstData;

   582     jboolean srcAtOnce = JNI_FALSE, dstAtOnce = JNI_FALSE;

   583 

   584     srcOffset = (*env)->GetIntField (env, src, IL_offset_fID);

   585     srcNextRowOffset = (*env)->GetIntField (env, src, IL_nextRowOffset_fID);

   586     dstOffset = (*env)->GetIntField (env, dst, IL_offset_fID);

   587     dstNextRowOffset = (*env)->GetIntField (env, dst, IL_nextRowOffset_fID);

   588     width = (*env)->GetIntField (env, src, IL_width_fID);

   589     height = (*env)->GetIntField (env, src, IL_height_fID);

   590 

   591     srcAtOnce = (*env)->GetBooleanField(env, src, IL_imageAtOnce_fID);

   592     dstAtOnce = (*env)->GetBooleanField(env, dst, IL_imageAtOnce_fID);

   593 

   594     sTrans = jlong_to_ptr((*env)->GetLongField (env, trans, Trans_ID_fID));

   595 

   596     if (sTrans == NULL) {

   597         J2dRlsTraceLn(J2D_TRACE_ERROR, "LCMS_colorConvert: transform == NULL");

   598         JNU_ThrowByName(env, "java/awt/color/CMMException",

   599                         "Cannot get color transform");

   600         return;

   601     }

   602 

   603 

   604     inputBuffer = getILData (env, src, &srcDType, &srcData);

   605 

   606     if (inputBuffer == NULL) {

   607         J2dRlsTraceLn(J2D_TRACE_ERROR, "");

   608         // An exception should have already been thrown.

   609         return;

   610     }

   611 

   612     outputBuffer = getILData (env, dst, &dstDType, &dstData);

   613 

   614     if (outputBuffer == NULL) {

   615         releaseILData(env, inputBuffer, srcDType, srcData);

   616         // An exception should have already been thrown.

   617         return;

   618     }

   619 

   620     inputRow = (char*)inputBuffer + srcOffset;

   621     outputRow = (char*)outputBuffer + dstOffset;

   622 

   623     if (srcAtOnce && dstAtOnce) {

   624         cmsDoTransform(sTrans, inputRow, outputRow, width * height);

   625     } else {

   626         for (i = 0; i < height; i++) {

   627             cmsDoTransform(sTrans, inputRow, outputRow, width);

   628             inputRow += srcNextRowOffset;

   629             outputRow += dstNextRowOffset;

   630         }

   631     }

   632 

   633     releaseILData(env, inputBuffer, srcDType, srcData);

   634     releaseILData(env, outputBuffer, dstDType, dstData);

   635 }

   636 

   637 /*

   638  * Class:     sun_java2d_cmm_lcms_LCMS

   639  * Method:    getProfileID

   640  * Signature: (Ljava/awt/color/ICC_Profile;)Lsun/java2d/cmm/lcms/LCMSProfile

   641  */

   642 JNIEXPORT jobject JNICALL Java_sun_java2d_cmm_lcms_LCMS_getProfileID

   643   (JNIEnv *env, jclass cls, jobject pf)

   644 {

   645     jclass clsLcmsProfile;

   646     jobject cmmProfile;

   647     jfieldID fid = (*env)->GetFieldID (env,

   648         (*env)->GetObjectClass(env, pf),

   649         "cmmProfile", "Lsun/java2d/cmm/Profile;");

   650     if (fid == NULL) {

   651         return NULL;

   652     }

   653 

   654     clsLcmsProfile = (*env)->FindClass(env,

   655             "sun/java2d/cmm/lcms/LCMSProfile");

   656     if (clsLcmsProfile == NULL) {

   657         return NULL;

   658     }

   659 

   660     cmmProfile = (*env)->GetObjectField (env, pf, fid);

   661 

   662     if (JNU_IsNull(env, cmmProfile)) {

   663         return NULL;

   664     }

   665     if ((*env)->IsInstanceOf(env, cmmProfile, clsLcmsProfile)) {

   666         return cmmProfile;

   667     }

   668     return NULL;

   669 }

   670 

   671 /*

   672  * Class:     sun_java2d_cmm_lcms_LCMS

   673  * Method:    initLCMS

   674  * Signature: (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;)V

   675  */

   676 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_initLCMS

   677   (JNIEnv *env, jclass cls, jclass Trans, jclass IL, jclass Pf)

   678 {

   679     /* TODO: move initialization of the IDs to the static blocks of

   680      * corresponding classes to avoid problems with invalidating ids by class

   681      * unloading

   682      */

   683     Trans_renderType_fID = (*env)->GetFieldID (env, Trans, "renderType", "I");

   684     if (Trans_renderType_fID == NULL) {

   685         return;

   686     }

   687     Trans_ID_fID = (*env)->GetFieldID (env, Trans, "ID", "J");

   688     if (Trans_ID_fID == NULL) {

   689         return;

   690     }

   691 

   692     IL_isIntPacked_fID = (*env)->GetFieldID (env, IL, "isIntPacked", "Z");

   693     if (IL_isIntPacked_fID == NULL) {

   694         return;

   695     }

   696     IL_dataType_fID = (*env)->GetFieldID (env, IL, "dataType", "I");

   697     if (IL_dataType_fID == NULL) {

   698         return;

   699     }

   700     IL_pixelType_fID = (*env)->GetFieldID (env, IL, "pixelType", "I");

   701     if (IL_pixelType_fID == NULL) {

   702         return;

   703     }

   704     IL_dataArray_fID = (*env)->GetFieldID(env, IL, "dataArray",

   705                                           "Ljava/lang/Object;");

   706     if (IL_dataArray_fID == NULL) {

   707         return;

   708     }

   709     IL_width_fID = (*env)->GetFieldID (env, IL, "width", "I");

   710     if (IL_width_fID == NULL) {

   711         return;

   712     }

   713     IL_height_fID = (*env)->GetFieldID (env, IL, "height", "I");

   714     if (IL_height_fID == NULL) {

   715         return;

   716     }

   717     IL_offset_fID = (*env)->GetFieldID (env, IL, "offset", "I");

   718     if (IL_offset_fID == NULL) {

   719         return;

   720     }

   721     IL_imageAtOnce_fID = (*env)->GetFieldID (env, IL, "imageAtOnce", "Z");

   722     if (IL_imageAtOnce_fID == NULL) {

   723         return;

   724     }

   725     IL_nextRowOffset_fID = (*env)->GetFieldID (env, IL, "nextRowOffset", "I");

   726     if (IL_nextRowOffset_fID == NULL) {

   727         return;

   728     }

   729 }

   730 

   731 static cmsBool _getHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize)

   732 {

   733   cmsUInt32Number pfSize = 0;

   734   cmsUInt8Number* pfBuffer = NULL;

   735   cmsBool status = FALSE;

   736 

   737   if (!cmsSaveProfileToMem(pf, NULL, &pfSize) ||

   738       pfSize < sizeof(cmsICCHeader) ||

   739       bufferSize < (jint)sizeof(cmsICCHeader))

   740   {

   741     return FALSE;

   742   }

   743 

   744   pfBuffer = malloc(pfSize);

   745   if (pfBuffer == NULL) {

   746     return FALSE;

   747   }

   748 

   749   // load raw profile data into the buffer

   750   if (cmsSaveProfileToMem(pf, pfBuffer, &pfSize)) {

   751     memcpy(pBuffer, pfBuffer, sizeof(cmsICCHeader));

   752     status = TRUE;

   753   }

   754   free(pfBuffer);

   755   return status;

   756 }

   757 

   758 static cmsBool _setHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize)

   759 {

   760   cmsICCHeader pfHeader;

   761 

   762   if (pBuffer == NULL || bufferSize < (jint)sizeof(cmsICCHeader)) {

   763     return FALSE;

   764   }

   765 

   766   memcpy(&pfHeader, pBuffer, sizeof(cmsICCHeader));

   767 

   768   // now set header fields, which we can access using the lcms2 public API

   769   cmsSetHeaderFlags(pf, pfHeader.flags);

   770   cmsSetHeaderManufacturer(pf, pfHeader.manufacturer);

   771   cmsSetHeaderModel(pf, pfHeader.model);

   772   cmsSetHeaderAttributes(pf, pfHeader.attributes);

   773   cmsSetHeaderProfileID(pf, (cmsUInt8Number*)&(pfHeader.profileID));

   774   cmsSetHeaderRenderingIntent(pf, pfHeader.renderingIntent);

   775   cmsSetPCS(pf, pfHeader.pcs);

   776   cmsSetColorSpace(pf, pfHeader.colorSpace);

   777   cmsSetDeviceClass(pf, pfHeader.deviceClass);

   778   cmsSetEncodedICCversion(pf, pfHeader.version);

   779 

   780   return TRUE;

   781 }

   782 

   783 /* Returns new profile handler, if it was created successfully,

   784    NULL otherwise.

   785    */

   786 static cmsHPROFILE _writeCookedTag(const cmsHPROFILE pfTarget,

   787                                const cmsTagSignature sig,

   788                                jbyte *pData, jint size)

   789 {

   790     cmsUInt32Number pfSize = 0;

   791     const cmsInt32Number tagCount = cmsGetTagCount(pfTarget);

   792     cmsInt32Number i;

   793     cmsHPROFILE pfSanity = NULL;

   794 

   795     cmsICCHeader hdr;

   796 

   797     cmsHPROFILE p = cmsCreateProfilePlaceholder(NULL);

   798 

   799     if (NULL == p) {

   800         return NULL;

   801     }

   802     memset(&hdr, 0, sizeof(cmsICCHeader));

   803 

   804     // Populate the placeholder's header according to target profile

   805     hdr.flags = cmsGetHeaderFlags(pfTarget);

   806     hdr.renderingIntent = cmsGetHeaderRenderingIntent(pfTarget);

   807     hdr.manufacturer = cmsGetHeaderManufacturer(pfTarget);

   808     hdr.model = cmsGetHeaderModel(pfTarget);

   809     hdr.pcs = cmsGetPCS(pfTarget);

   810     hdr.colorSpace = cmsGetColorSpace(pfTarget);

   811     hdr.deviceClass = cmsGetDeviceClass(pfTarget);

   812     hdr.version = cmsGetEncodedICCversion(pfTarget);

   813     cmsGetHeaderAttributes(pfTarget, &hdr.attributes);

   814     cmsGetHeaderProfileID(pfTarget, (cmsUInt8Number*)&hdr.profileID);

   815 

   816     cmsSetHeaderFlags(p, hdr.flags);

   817     cmsSetHeaderManufacturer(p, hdr.manufacturer);

   818     cmsSetHeaderModel(p, hdr.model);

   819     cmsSetHeaderAttributes(p, hdr.attributes);

   820     cmsSetHeaderProfileID(p, (cmsUInt8Number*)&(hdr.profileID));

   821     cmsSetHeaderRenderingIntent(p, hdr.renderingIntent);

   822     cmsSetPCS(p, hdr.pcs);

   823     cmsSetColorSpace(p, hdr.colorSpace);

   824     cmsSetDeviceClass(p, hdr.deviceClass);

   825     cmsSetEncodedICCversion(p, hdr.version);

   826 

   827     // now write the user supplied tag

   828     if (size <= 0 || !cmsWriteRawTag(p, sig, pData, size)) {

   829         cmsCloseProfile(p);

   830         return NULL;

   831     }

   832 

   833     // copy tags from the original profile

   834     for (i = 0; i < tagCount; i++) {

   835         cmsBool isTagReady = FALSE;

   836         const cmsTagSignature s = cmsGetTagSignature(pfTarget, i);

   837         const cmsInt32Number tagSize = cmsReadRawTag(pfTarget, s, NULL, 0);

   838 

   839         if (s == sig) {

   840             // skip the user supplied tag

   841             continue;

   842         }

   843 

   844         // read raw tag from the original profile

   845         if (tagSize > 0) {

   846             cmsUInt8Number* buf = (cmsUInt8Number*)malloc(tagSize);

   847             if (buf != NULL) {

   848                 if (tagSize ==  cmsReadRawTag(pfTarget, s, buf, tagSize)) {

   849                     // now we are ready to write the tag

   850                     isTagReady = cmsWriteRawTag(p, s, buf, tagSize);

   851                 }

   852                 free(buf);

   853             }

   854         }

   855 

   856         if (!isTagReady) {

   857             cmsCloseProfile(p);

   858             return NULL;

   859         }

   860     }

   861 

   862     // now we have all tags moved to the new profile.

   863     // do some sanity checks: write it to a memory buffer and read again.

   864     if (cmsSaveProfileToMem(p, NULL, &pfSize)) {

   865         void* buf = malloc(pfSize);

   866         if (buf != NULL) {

   867             // load raw profile data into the buffer

   868             if (cmsSaveProfileToMem(p, buf, &pfSize)) {

   869                 pfSanity = cmsOpenProfileFromMem(buf, pfSize);

   870             }

   871             free(buf);

   872         }

   873     }

   874 

   875     if (pfSanity == NULL) {

   876         // for some reason, we failed to save and read the updated profile

   877         // It likely indicates that the profile is not correct, so we report

   878         // a failure here.

   879         cmsCloseProfile(p);

   880         p =  NULL;

   881     } else {

   882         // do final check whether we can read and handle the target tag.

   883         const void* pTag = cmsReadTag(pfSanity, sig);

   884         if (pTag == NULL) {

   885             // the tag can not be cooked

   886             cmsCloseProfile(p);

   887             p = NULL;

   888         }

   889         cmsCloseProfile(pfSanity);

   890         pfSanity = NULL;

   891     }

   892 

   893     return p;

   894 }