1 /*
   2  * Copyright (c) 2007, 2011, 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 
  35 
  36 #define ALIGNLONG(x) (((x)+3) & ~(3))         // Aligns to DWORD boundary
  37 
  38 #ifdef USE_BIG_ENDIAN
  39 #define AdjustEndianess32(a)
  40 #else
  41 
  42 static
  43 void AdjustEndianess32(cmsUInt8Number *pByte)
  44 {
  45     cmsUInt8Number temp1;
  46     cmsUInt8Number temp2;
  47 
  48     temp1 = *pByte++;
  49     temp2 = *pByte++;
  50     *(pByte-1) = *pByte;
  51     *pByte++ = temp2;
  52     *(pByte-3) = *pByte;
  53     *pByte = temp1;
  54 }
  55 
  56 #endif
  57 
  58 // Transports to properly encoded values - note that icc profiles does use
  59 // big endian notation.
  60 
  61 static
  62 cmsInt32Number TransportValue32(cmsInt32Number Value)
  63 {
  64     cmsInt32Number Temp = Value;
  65 
  66     AdjustEndianess32((cmsUInt8Number*) &Temp);
  67     return Temp;
  68 }
  69 
  70 #define SigMake(a,b,c,d) \
  71                     ( ( ((int) ((unsigned char) (a))) << 24) | \
  72                       ( ((int) ((unsigned char) (b))) << 16) | \
  73                       ( ((int) ((unsigned char) (c))) <<  8) | \
  74                           (int) ((unsigned char) (d)))
  75 
  76 #define TagIdConst(a, b, c, d) \
  77                 ((int) SigMake ((a), (b), (c), (d)))
  78 
  79 #define SigHead TagIdConst('h','e','a','d')
  80 
  81 #define DT_BYTE     0
  82 #define DT_SHORT    1
  83 #define DT_INT      2
  84 #define DT_DOUBLE   3
  85 
  86 /* Default temp profile list size */
  87 #define DF_ICC_BUF_SIZE 32
  88 
  89 #define ERR_MSG_SIZE 256
  90 
  91 #ifdef _MSC_VER
  92 # ifndef snprintf
  93 #       define snprintf  _snprintf
  94 # endif
  95 #endif
  96 
  97 typedef union storeID_s {    /* store SProfile stuff in a Java Long */
  98     cmsHPROFILE pf;
  99     cmsHTRANSFORM xf;
 100     jobject jobj;
 101     jlong j;
 102 } storeID_t, *storeID_p;
 103 
 104 typedef union {
 105     cmsTagSignature cms;
 106     jint j;
 107 } TagSignature_t, *TagSignature_p;
 108 
 109 static jfieldID Trans_profileIDs_fID;
 110 static jfieldID Trans_renderType_fID;
 111 static jfieldID Trans_ID_fID;
 112 static jfieldID IL_isIntPacked_fID;
 113 static jfieldID IL_dataType_fID;
 114 static jfieldID IL_pixelType_fID;
 115 static jfieldID IL_dataArray_fID;
 116 static jfieldID IL_offset_fID;
 117 static jfieldID IL_nextRowOffset_fID;
 118 static jfieldID IL_width_fID;
 119 static jfieldID IL_height_fID;

 120 static jfieldID PF_ID_fID;
 121 
 122 JavaVM *javaVM;
 123 
 124 void errorHandler(cmsContext ContextID, cmsUInt32Number errorCode,
 125                   const char *errorText) {
 126     JNIEnv *env;
 127     char errMsg[ERR_MSG_SIZE];
 128 
 129     int count = snprintf(errMsg, ERR_MSG_SIZE,
 130                           "LCMS error %d: %s", errorCode, errorText);
 131     if (count < 0 || count >= ERR_MSG_SIZE) {
 132         count = ERR_MSG_SIZE - 1;
 133     }
 134     errMsg[count] = 0;
 135 
 136     (*javaVM)->AttachCurrentThread(javaVM, (void**)&env, NULL);
 137     JNU_ThrowByName(env, "java/awt/color/CMMException", errMsg);
 138 }
 139 
 140 JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *jvm, void *reserved) {
 141     javaVM = jvm;
 142 
 143     cmsSetLogErrorHandler(errorHandler);
 144     return JNI_VERSION_1_6;
 145 }
 146 
 147 void LCMS_freeTransform(JNIEnv *env, jlong ID)
 148 {
 149     storeID_t sTrans;
 150     sTrans.j = ID;
 151     /* Passed ID is always valid native ref so there is no check for zero */
 152     cmsDeleteTransform(sTrans.xf);
 153 }
 154 
 155 /*
 156  * Class:     sun_java2d_cmm_lcms_LCMS
 157  * Method:    createNativeTransform
 158  * Signature: ([JI)J
 159  */
 160 JNIEXPORT jlong JNICALL Java_sun_java2d_cmm_lcms_LCMS_createNativeTransform
 161   (JNIEnv *env, jclass cls, jlongArray profileIDs, jint renderType,
 162    jint inFormatter, jboolean isInIntPacked,
 163    jint outFormatter, jboolean isOutIntPacked, jobject disposerRef)
 164 {
 165     cmsHPROFILE _iccArray[DF_ICC_BUF_SIZE];
 166     cmsHPROFILE *iccArray = &_iccArray[0];
 167     storeID_t sTrans;
 168     int i, j, size;
 169     jlong* ids;
 170 
 171     size = (*env)->GetArrayLength (env, profileIDs);
 172     ids = (*env)->GetPrimitiveArrayCritical(env, profileIDs, 0);
 173 
 174 #ifdef _LITTLE_ENDIAN
 175     /* Reversing data packed into int for LE archs */
 176     if (isInIntPacked) {
 177         inFormatter ^= DOSWAP_SH(1);
 178     }
 179     if (isOutIntPacked) {
 180         outFormatter ^= DOSWAP_SH(1);
 181     }
 182 #endif
 183 
 184     if (DF_ICC_BUF_SIZE < size*2) {
 185         iccArray = (cmsHPROFILE*) malloc(
 186             size*2*sizeof(cmsHPROFILE));
 187         if (iccArray == NULL) {
 188             J2dRlsTraceLn(J2D_TRACE_ERROR, "getXForm: iccArray == NULL");
 189             return 0L;
 190         }
 191     }
 192 
 193     j = 0;
 194     for (i = 0; i < size; i++) {
 195         cmsHPROFILE icc;
 196         cmsColorSpaceSignature cs;
 197 
 198         sTrans.j = ids[i];
 199         icc = sTrans.pf;
 200         iccArray[j++] = icc;
 201 
 202         /* Middle non-abstract profiles should be doubled before passing to
 203          * the cmsCreateMultiprofileTransform function
 204          */
 205 
 206         cs = cmsGetColorSpace(icc);
 207         if (size > 2 && i != 0 && i != size - 1 &&
 208             cs != cmsSigXYZData && cs != cmsSigLabData)
 209         {
 210             iccArray[j++] = icc;
 211         }
 212     }
 213 
 214     sTrans.xf = cmsCreateMultiprofileTransform(iccArray, j,
 215         inFormatter, outFormatter, renderType, 0);
 216 
 217     (*env)->ReleasePrimitiveArrayCritical(env, profileIDs, ids, 0);
 218 
 219     if (sTrans.xf == NULL) {
 220         J2dRlsTraceLn(J2D_TRACE_ERROR, "LCMS_createNativeTransform: "
 221                                        "sTrans.xf == NULL");
 222         JNU_ThrowByName(env, "java/awt/color/CMMException",
 223                         "Cannot get color transform");
 224     } else {
 225         Disposer_AddRecord(env, disposerRef, LCMS_freeTransform, sTrans.j);
 226     }
 227 
 228     if (iccArray != &_iccArray[0]) {
 229         free(iccArray);
 230     }
 231     return sTrans.j;
 232 }
 233 
 234 
 235 /*
 236  * Class:     sun_java2d_cmm_lcms_LCMS
 237  * Method:    loadProfile
 238  * Signature: ([B)J
 239  */
 240 JNIEXPORT jlong JNICALL Java_sun_java2d_cmm_lcms_LCMS_loadProfile
 241   (JNIEnv *env, jobject obj, jbyteArray data)
 242 {
 243     jbyte* dataArray;
 244     jint dataSize;
 245     storeID_t sProf;
 246 
 247     if (JNU_IsNull(env, data)) {
 248         JNU_ThrowIllegalArgumentException(env, "Invalid profile data");
 249         return 0L;
 250     }
 251 
 252     dataArray = (*env)->GetByteArrayElements (env, data, 0);
 253     dataSize = (*env)->GetArrayLength (env, data);
 254 
 255     if (dataArray == NULL) {
 256         JNU_ThrowIllegalArgumentException(env, "Invalid profile data");
 257         return 0L;
 258     }
 259 
 260     sProf.pf = cmsOpenProfileFromMem((const void *)dataArray,
 261                                      (cmsUInt32Number) dataSize);
 262 
 263     (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);
 264 
 265     if (sProf.pf == NULL) {
 266         JNU_ThrowIllegalArgumentException(env, "Invalid profile data");
 267     } else {
 268         /* Sanity check: try to save the profile in order
 269          * to force basic validation.
 270          */
 271         cmsUInt32Number pfSize = 0;
 272         if (!cmsSaveProfileToMem(sProf.pf, NULL, &pfSize) ||
 273             pfSize < sizeof(cmsICCHeader))
 274         {
 275             JNU_ThrowIllegalArgumentException(env, "Invalid profile data");
 276         }
 277     }
 278 
 279     return sProf.j;
 280 }
 281 
 282 /*
 283  * Class:     sun_java2d_cmm_lcms_LCMS
 284  * Method:    freeProfile
 285  * Signature: (J)V
 286  */
 287 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_freeProfile
 288   (JNIEnv *env, jobject obj, jlong id)
 289 {
 290     storeID_t sProf;
 291 
 292     sProf.j = id;
 293     if (cmsCloseProfile(sProf.pf) == 0) {
 294         J2dRlsTraceLn1(J2D_TRACE_ERROR, "LCMS_freeProfile: cmsCloseProfile(%d)"
 295                        "== 0", id);
 296         JNU_ThrowByName(env, "java/awt/color/CMMException",
 297                         "Cannot close profile");
 298     }
 299 
 300 }
 301 
 302 /*
 303  * Class:     sun_java2d_cmm_lcms_LCMS
 304  * Method:    getProfileSize
 305  * Signature: (J)I
 306  */
 307 JNIEXPORT jint JNICALL Java_sun_java2d_cmm_lcms_LCMS_getProfileSize
 308   (JNIEnv *env, jobject obj, jlong id)
 309 {
 310     storeID_t sProf;
 311     cmsUInt32Number pfSize = 0;
 312     sProf.j = id;
 313 
 314     if (cmsSaveProfileToMem(sProf.pf, NULL, &pfSize) && ((jint)pfSize > 0)) {
 315         return (jint)pfSize;
 316     } else {
 317       JNU_ThrowByName(env, "java/awt/color/CMMException",
 318                       "Can not access specified profile.");
 319         return -1;
 320     }
 321 }
 322 
 323 /*
 324  * Class:     sun_java2d_cmm_lcms_LCMS
 325  * Method:    getProfileData
 326  * Signature: (J[B)V
 327  */
 328 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_getProfileData
 329   (JNIEnv *env, jobject obj, jlong id, jbyteArray data)
 330 {
 331     storeID_t sProf;
 332     jint size;
 333     jbyte* dataArray;
 334     cmsUInt32Number pfSize = 0;
 335     cmsBool status;
 336 
 337     sProf.j = id;
 338 
 339     // determine actual profile size
 340     if (!cmsSaveProfileToMem(sProf.pf, NULL, &pfSize)) {
 341         JNU_ThrowByName(env, "java/awt/color/CMMException",
 342                         "Can not access specified profile.");
 343         return;
 344     }
 345 
 346     // verify java buffer capacity
 347     size = (*env)->GetArrayLength(env, data);
 348     if (0 >= size || pfSize > (cmsUInt32Number)size) {
 349         JNU_ThrowByName(env, "java/awt/color/CMMException",
 350                         "Insufficient buffer capacity.");
 351         return;
 352     }
 353 
 354     dataArray = (*env)->GetByteArrayElements (env, data, 0);
 355 
 356     status = cmsSaveProfileToMem(sProf.pf, dataArray, &pfSize);
 357 
 358     (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);
 359 
 360     if (!status) {
 361         JNU_ThrowByName(env, "java/awt/color/CMMException",
 362                         "Can not access specified profile.");
 363         return;
 364     }
 365 }
 366 
 367 /* Get profile header info */
 368 static cmsBool _getHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize);
 369 static cmsBool _setHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize);
 370 static cmsBool _writeCookedTag(cmsHPROFILE pfTarget, cmsTagSignature sig, jbyte *pData, jint size);
 371 
 372 /*
 373  * Class:     sun_java2d_cmm_lcms_LCMS
 374  * Method:    getTagSize
 375  * Signature: (JI)I
 376  */
 377 JNIEXPORT jint JNICALL Java_sun_java2d_cmm_lcms_LCMS_getTagSize
 378   (JNIEnv *env, jobject obj, jlong id, jint tagSig)
 379 {
 380     storeID_t sProf;
 381     TagSignature_t sig;
 382     jint result = -1;
 383 
 384     sProf.j = id;
 385     sig.j = tagSig;
 386 
 387     if (tagSig == SigHead) {
 388         result = sizeof(cmsICCHeader);
 389     } else {
 390       if (cmsIsTag(sProf.pf, sig.cms)) {
 391           result = cmsReadRawTag(sProf.pf, sig.cms, NULL, 0);
 392         } else {
 393             JNU_ThrowByName(env, "java/awt/color/CMMException",
 394                             "ICC profile tag not found");
 395         }
 396     }
 397 
 398     return result;
 399 }
 400 
 401 /*
 402  * Class:     sun_java2d_cmm_lcms_LCMS
 403  * Method:    getTagData
 404  * Signature: (JI[B)V
 405  */
 406 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_getTagData
 407   (JNIEnv *env, jobject obj, jlong id, jint tagSig, jbyteArray data)
 408 {
 409     storeID_t sProf;
 410     TagSignature_t sig;
 411     cmsInt32Number tagSize;
 412 
 413     jbyte* dataArray;


 414     jint bufSize;
 415 
 416     sProf.j = id;
 417     sig.j = tagSig;
 418 
 419     if (tagSig == SigHead) {
 420         cmsBool status;
 421 
 422         bufSize =(*env)->GetArrayLength(env, data);


 423 
 424         if (bufSize < sizeof(cmsICCHeader)) {
 425            JNU_ThrowByName(env, "java/awt/color/CMMException",
 426                             "Insufficient buffer capacity");
 427            return;
 428         }
 429 
 430         dataArray = (*env)->GetByteArrayElements (env, data, 0);
 431 
 432         if (dataArray == NULL) {
 433            JNU_ThrowByName(env, "java/awt/color/CMMException",
 434                             "Unable to get buffer");
 435            return;
 436         }
 437 
 438         status = _getHeaderInfo(sProf.pf, dataArray, bufSize);
 439 
 440         (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);
 441 
 442         if (!status) {
 443             JNU_ThrowByName(env, "java/awt/color/CMMException",
 444                             "ICC Profile header not found");

 445         }
 446 
 447         return;
 448     }
 449 
 450     if (cmsIsTag(sProf.pf, sig.cms)) {
 451         tagSize = cmsReadRawTag(sProf.pf, sig.cms, NULL, 0);
 452     } else {
 453         JNU_ThrowByName(env, "java/awt/color/CMMException",
 454                         "ICC profile tag not found");
 455         return;
 456     }
 457 
 458     // verify data buffer capacity
 459     bufSize = (*env)->GetArrayLength(env, data);
 460 
 461     if (tagSize < 0 || 0 > bufSize || tagSize > bufSize) {
 462         JNU_ThrowByName(env, "java/awt/color/CMMException",
 463                         "Insufficient buffer capacity.");
 464         return;
 465     }
 466 
 467     dataArray = (*env)->GetByteArrayElements (env, data, 0);
 468 
 469     if (dataArray == NULL) {
 470         JNU_ThrowByName(env, "java/awt/color/CMMException",
 471                         "Unable to get buffer");
 472         return;
 473     }
 474 
 475     bufSize = cmsReadRawTag(sProf.pf, sig.cms, dataArray, tagSize);
 476 
 477     (*env)->ReleaseByteArrayElements (env, data, dataArray, 0);
 478 
 479     if (bufSize != tagSize) {
 480         JNU_ThrowByName(env, "java/awt/color/CMMException",
 481                         "Can not get tag data.");

 482     }
 483     return;
 484 }
 485 
 486 /*
 487  * Class:     sun_java2d_cmm_lcms_LCMS
 488  * Method:    setTagData
 489  * Signature: (JI[B)V
 490  */
 491 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_setTagData
 492   (JNIEnv *env, jobject obj, jlong id, jint tagSig, jbyteArray data)
 493 {
 494     storeID_t sProf;
 495     TagSignature_t sig;
 496     cmsBool status;
 497     jbyte* dataArray;
 498     int tagSize;
 499 
 500     sProf.j = id;
 501     sig.j = tagSig;
 502 
 503     if (JNU_IsNull(env, data)) {
 504         JNU_ThrowIllegalArgumentException(env, "Can not write tag data.");
 505         return;
 506     }
 507 
 508     tagSize =(*env)->GetArrayLength(env, data);
 509 
 510     dataArray = (*env)->GetByteArrayElements(env, data, 0);
 511 
 512     if (dataArray == NULL) {
 513         JNU_ThrowIllegalArgumentException(env, "Can not write tag data.");
 514         return;
 515     }
 516 
 517     if (tagSig == SigHead) {
 518         status = _setHeaderInfo(sProf.pf, dataArray, tagSize);
 519     } else {
 520         status = _writeCookedTag(sProf.pf, sig.cms, dataArray, tagSize);
 521     }
 522 
 523     (*env)->ReleaseByteArrayElements(env, data, dataArray, 0);
 524 
 525     if (!status) {
 526         JNU_ThrowIllegalArgumentException(env, "Can not write tag data.");
 527     }
 528 }
 529 
 530 void* getILData (JNIEnv *env, jobject img, jint* pDataType,
 531                  jobject* pDataObject) {
 532     void* result = NULL;
 533     *pDataType = (*env)->GetIntField (env, img, IL_dataType_fID);
 534     *pDataObject = (*env)->GetObjectField(env, img, IL_dataArray_fID);
 535     switch (*pDataType) {
 536         case DT_BYTE:
 537             result = (*env)->GetByteArrayElements (env, *pDataObject, 0);
 538             break;
 539         case DT_SHORT:
 540             result = (*env)->GetShortArrayElements (env, *pDataObject, 0);
 541             break;
 542         case DT_INT:
 543             result = (*env)->GetIntArrayElements (env, *pDataObject, 0);
 544             break;
 545         case DT_DOUBLE:
 546             result = (*env)->GetDoubleArrayElements (env, *pDataObject, 0);
 547             break;
 548     }
 549 
 550     return result;
 551 }
 552 
 553 void releaseILData (JNIEnv *env, void* pData, jint dataType,
 554                     jobject dataObject) {
 555     switch (dataType) {
 556         case DT_BYTE:
 557             (*env)->ReleaseByteArrayElements(env,dataObject,(jbyte*)pData,0);
 558             break;
 559         case DT_SHORT:
 560             (*env)->ReleaseShortArrayElements(env,dataObject,(jshort*)pData, 0);
 561             break;
 562         case DT_INT:
 563             (*env)->ReleaseIntArrayElements(env,dataObject,(jint*)pData,0);
 564             break;
 565         case DT_DOUBLE:
 566             (*env)->ReleaseDoubleArrayElements(env,dataObject,(jdouble*)pData,
 567                                                0);
 568             break;
 569     }
 570 }
 571 
 572 /*
 573  * Class:     sun_java2d_cmm_lcms_LCMS
 574  * Method:    colorConvert
 575  * Signature: (Lsun/java2d/cmm/lcms/LCMSTransform;Lsun/java2d/cmm/lcms/LCMSImageLayout;Lsun/java2d/cmm/lcms/LCMSImageLayout;)V
 576  */
 577 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_colorConvert
 578   (JNIEnv *env, jclass obj, jobject trans, jobject src, jobject dst)
 579 {
 580     storeID_t sTrans;
 581     int srcDType, dstDType;
 582     int srcOffset, srcNextRowOffset, dstOffset, dstNextRowOffset;
 583     int width, height, i;
 584     void* inputBuffer;
 585     void* outputBuffer;
 586     char* inputRow;
 587     char* outputRow;
 588     jobject srcData, dstData;

 589 
 590     srcOffset = (*env)->GetIntField (env, src, IL_offset_fID);
 591     srcNextRowOffset = (*env)->GetIntField (env, src, IL_nextRowOffset_fID);
 592     dstOffset = (*env)->GetIntField (env, dst, IL_offset_fID);
 593     dstNextRowOffset = (*env)->GetIntField (env, dst, IL_nextRowOffset_fID);
 594     width = (*env)->GetIntField (env, src, IL_width_fID);
 595     height = (*env)->GetIntField (env, src, IL_height_fID);
 596 



 597     sTrans.j = (*env)->GetLongField (env, trans, Trans_ID_fID);
 598 
 599     if (sTrans.xf == NULL) {
 600         J2dRlsTraceLn(J2D_TRACE_ERROR, "LCMS_colorConvert: transform == NULL");
 601         JNU_ThrowByName(env, "java/awt/color/CMMException",
 602                         "Cannot get color transform");
 603         return;
 604     }
 605 
 606 
 607     inputBuffer = getILData (env, src, &srcDType, &srcData);
 608 
 609     if (inputBuffer == NULL) {
 610         J2dRlsTraceLn(J2D_TRACE_ERROR, "");
 611         JNU_ThrowByName(env, "java/awt/color/CMMException",
 612                         "Cannot get input data");
 613         return;
 614     }
 615 
 616     outputBuffer = getILData (env, dst, &dstDType, &dstData);
 617 
 618     if (outputBuffer == NULL) {
 619         releaseILData(env, inputBuffer, srcDType, srcData);
 620         JNU_ThrowByName(env, "java/awt/color/CMMException",
 621                         "Cannot get output data");
 622         return;
 623     }
 624 
 625     inputRow = (char*)inputBuffer + srcOffset;
 626     outputRow = (char*)outputBuffer + dstOffset;
 627 



 628     for (i = 0; i < height; i++) {
 629         cmsDoTransform(sTrans.xf, inputRow, outputRow, width);
 630         inputRow += srcNextRowOffset;
 631         outputRow += dstNextRowOffset;
 632     }

 633 
 634     releaseILData(env, inputBuffer, srcDType, srcData);
 635     releaseILData(env, outputBuffer, dstDType, dstData);
 636 }
 637 
 638 /*
 639  * Class:     sun_java2d_cmm_lcms_LCMS
 640  * Method:    getProfileID
 641  * Signature: (Ljava/awt/color/ICC_Profile;)J
 642  */
 643 JNIEXPORT jlong JNICALL Java_sun_java2d_cmm_lcms_LCMS_getProfileID
 644   (JNIEnv *env, jclass cls, jobject pf)
 645 {
 646     return (*env)->GetLongField (env, pf, PF_ID_fID);
 647 }
 648 
 649 /*
 650  * Class:     sun_java2d_cmm_lcms_LCMS
 651  * Method:    initLCMS
 652  * Signature: (Ljava/lang/Class;Ljava/lang/Class;Ljava/lang/Class;)V
 653  */
 654 JNIEXPORT void JNICALL Java_sun_java2d_cmm_lcms_LCMS_initLCMS
 655   (JNIEnv *env, jclass cls, jclass Trans, jclass IL, jclass Pf)
 656 {
 657     /* TODO: move initialization of the IDs to the static blocks of
 658      * corresponding classes to avoid problems with invalidating ids by class
 659      * unloading
 660      */
 661     Trans_profileIDs_fID = (*env)->GetFieldID (env, Trans, "profileIDs", "[J");
 662     Trans_renderType_fID = (*env)->GetFieldID (env, Trans, "renderType", "I");
 663     Trans_ID_fID = (*env)->GetFieldID (env, Trans, "ID", "J");
 664 
 665     IL_isIntPacked_fID = (*env)->GetFieldID (env, IL, "isIntPacked", "Z");
 666     IL_dataType_fID = (*env)->GetFieldID (env, IL, "dataType", "I");
 667     IL_pixelType_fID = (*env)->GetFieldID (env, IL, "pixelType", "I");
 668     IL_dataArray_fID = (*env)->GetFieldID(env, IL, "dataArray",
 669                                           "Ljava/lang/Object;");
 670     IL_width_fID = (*env)->GetFieldID (env, IL, "width", "I");
 671     IL_height_fID = (*env)->GetFieldID (env, IL, "height", "I");
 672     IL_offset_fID = (*env)->GetFieldID (env, IL, "offset", "I");

 673     IL_nextRowOffset_fID = (*env)->GetFieldID (env, IL, "nextRowOffset", "I");
 674 
 675     PF_ID_fID = (*env)->GetFieldID (env, Pf, "ID", "J");
 676 }
 677 
 678 static cmsBool _getHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize)
 679 {
 680   cmsUInt32Number pfSize = 0;
 681   cmsUInt8Number* pfBuffer = NULL;
 682   cmsBool status = FALSE;
 683 
 684   if (!cmsSaveProfileToMem(pf, NULL, &pfSize) ||
 685       pfSize < sizeof(cmsICCHeader) ||
 686       bufferSize < sizeof(cmsICCHeader))
 687   {
 688     return FALSE;
 689   }
 690 
 691   pfBuffer = malloc(pfSize);
 692   if (pfBuffer == NULL) {
 693     return FALSE;
 694   }
 695 
 696   // load raw profile data into the buffer
 697   if (cmsSaveProfileToMem(pf, pfBuffer, &pfSize)) {
 698     memcpy(pBuffer, pfBuffer, sizeof(cmsICCHeader));
 699     status = TRUE;
 700   }
 701   free(pfBuffer);
 702   return status;
 703 }
 704 
 705 static cmsBool _setHeaderInfo(cmsHPROFILE pf, jbyte* pBuffer, jint bufferSize)
 706 {
 707   cmsICCHeader pfHeader = { 0 };
 708 
 709   if (pBuffer == NULL || bufferSize < sizeof(cmsICCHeader)) {
 710     return FALSE;
 711   }
 712 
 713   memcpy(&pfHeader, pBuffer, sizeof(cmsICCHeader));
 714 
 715   // now set header fields, which we can access using the lcms2 public API
 716   cmsSetHeaderFlags(pf, pfHeader.flags);
 717   cmsSetHeaderManufacturer(pf, pfHeader.manufacturer);
 718   cmsSetHeaderModel(pf, pfHeader.model);
 719   cmsSetHeaderAttributes(pf, pfHeader.attributes);
 720   cmsSetHeaderProfileID(pf, (cmsUInt8Number*)&(pfHeader.profileID));
 721   cmsSetHeaderRenderingIntent(pf, pfHeader.renderingIntent);
 722   cmsSetPCS(pf, pfHeader.pcs);
 723   cmsSetColorSpace(pf, pfHeader.colorSpace);
 724   cmsSetDeviceClass(pf, pfHeader.deviceClass);
 725   cmsSetEncodedICCversion(pf, pfHeader.version);
 726 
 727   return TRUE;
 728 }
 729 
 730 static cmsBool _writeCookedTag(cmsHPROFILE pfTarget,
 731                                cmsTagSignature sig,
 732                                jbyte *pData, jint size)
 733 {
 734     cmsBool status;
 735     cmsUInt32Number pfSize = 0;
 736     cmsUInt8Number* pfBuffer = NULL;
 737 
 738     cmsHPROFILE p = cmsCreateProfilePlaceholder(NULL);
 739     if (NULL != p) {
 740         cmsICCHeader hdr = { 0 };
 741 
 742         /* Populate the placeholder's header according to target profile */
 743         hdr.flags = cmsGetHeaderFlags(pfTarget);
 744         hdr.renderingIntent = cmsGetHeaderRenderingIntent(pfTarget);
 745         hdr.manufacturer = cmsGetHeaderManufacturer(pfTarget);
 746         hdr.model = cmsGetHeaderModel(pfTarget);
 747         hdr.pcs = cmsGetPCS(pfTarget);
 748         hdr.colorSpace = cmsGetColorSpace(pfTarget);
 749         hdr.deviceClass = cmsGetDeviceClass(pfTarget);
 750         hdr.version = cmsGetEncodedICCversion(pfTarget);
 751         cmsGetHeaderAttributes(pfTarget, &hdr.attributes);
 752         cmsGetHeaderProfileID(pfTarget, (cmsUInt8Number*)&hdr.profileID);
 753 
 754         cmsSetHeaderFlags(p, hdr.flags);
 755         cmsSetHeaderManufacturer(p, hdr.manufacturer);
 756         cmsSetHeaderModel(p, hdr.model);
 757         cmsSetHeaderAttributes(p, hdr.attributes);
 758         cmsSetHeaderProfileID(p, (cmsUInt8Number*)&(hdr.profileID));
 759         cmsSetHeaderRenderingIntent(p, hdr.renderingIntent);
 760         cmsSetPCS(p, hdr.pcs);
 761         cmsSetColorSpace(p, hdr.colorSpace);
 762         cmsSetDeviceClass(p, hdr.deviceClass);
 763         cmsSetEncodedICCversion(p, hdr.version);
 764 
 765 
 766         if (cmsWriteRawTag(p, sig, pData, size)) {
 767             if (cmsSaveProfileToMem(p, NULL, &pfSize)) {
 768                 pfBuffer = malloc(pfSize);
 769                 if (pfBuffer != NULL) {
 770                     /* load raw profile data into the buffer */
 771                     if (!cmsSaveProfileToMem(p, pfBuffer, &pfSize)) {
 772                         free(pfBuffer);
 773                         pfBuffer = NULL;
 774                     }
 775                 }
 776             }
 777         }
 778         cmsCloseProfile(p);
 779     }
 780 
 781     if (pfBuffer == NULL) {
 782         return FALSE;
 783     }
 784 
 785     /* re-open the placeholder profile */
 786     p = cmsOpenProfileFromMem(pfBuffer, pfSize);
 787     free(pfBuffer);
 788     status = FALSE;
 789 
 790     if (p != NULL) {
 791         /* Note that pCookedTag points to internal structures of the placeholder,
 792          * so this data is valid only while the placeholder is open.
 793          */
 794         void *pCookedTag = cmsReadTag(p, sig);
 795         if (pCookedTag != NULL) {
 796             status = cmsWriteTag(pfTarget, sig, pCookedTag);
 797         }
 798         pCookedTag = NULL;
 799         cmsCloseProfile(p);
 800     }
 801     return status;
 802 }
--- EOF ---