| /* |
| * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include <string.h> |
| |
| #include "jni.h" |
| #include "jni_util.h" |
| #include "awt_parseImage.h" |
| #include "imageInitIDs.h" |
| #include "sun_awt_image_ImageRepresentation.h" |
| |
| static int compareLUTs(unsigned int *lut1, int numLut1, int transIdx, |
| unsigned int *lut2, int numLut2, unsigned char *cvtLut, |
| int *retNumLut1, int *retTransIdx, int *jniFlagP); |
| |
| static int findIdx(unsigned int rgb, unsigned int *lut, int numLut1); |
| |
| #define ALPHA_MASK 0xff000000 |
| #ifndef FALSE |
| # define FALSE 0 |
| #endif |
| #ifndef TRUE |
| # define TRUE 1 |
| #endif |
| |
| #define CHECK_STRIDE(yy, hh, ss) \ |
| if ((ss) != 0) { \ |
| int limit = 0x7fffffff / ((ss) > 0 ? (ss) : -(ss)); \ |
| if (limit < (yy) || limit < ((yy) + (hh) - 1)) { \ |
| /* integer oveflow */ \ |
| return JNI_FALSE; \ |
| } \ |
| } \ |
| |
| #define CHECK_SRC() \ |
| do { \ |
| int pixeloffset; \ |
| if (off < 0 || off >= srcDataLength) { \ |
| return JNI_FALSE; \ |
| } \ |
| CHECK_STRIDE(0, h, scansize); \ |
| \ |
| /* check scansize */ \ |
| pixeloffset = scansize * (h - 1); \ |
| if ((w - 1) > (0x7fffffff - pixeloffset)) { \ |
| return JNI_FALSE; \ |
| } \ |
| pixeloffset += (w - 1); \ |
| \ |
| if (off > (0x7fffffff - pixeloffset)) { \ |
| return JNI_FALSE; \ |
| } \ |
| } while (0) \ |
| |
| #define CHECK_DST(xx, yy) \ |
| do { \ |
| int soffset = (yy) * sStride; \ |
| int poffset = (xx) * pixelStride; \ |
| if (poffset > (0x7fffffff - soffset)) { \ |
| return JNI_FALSE; \ |
| } \ |
| poffset += soffset; \ |
| if (dstDataOff > (0x7fffffff - poffset)) { \ |
| return JNI_FALSE; \ |
| } \ |
| poffset += dstDataOff; \ |
| \ |
| if (poffset < 0 || poffset >= dstDataLength) { \ |
| return JNI_FALSE; \ |
| } \ |
| } while (0) \ |
| |
| static jfieldID s_JnumSrcLUTID; |
| static jfieldID s_JsrcLUTtransIndexID; |
| |
| JNIEXPORT void JNICALL |
| Java_sun_awt_image_ImageRepresentation_initIDs(JNIEnv *env, jclass cls) { |
| CHECK_NULL(s_JnumSrcLUTID = (*env)->GetFieldID(env, cls, "numSrcLUT", "I")); |
| CHECK_NULL(s_JsrcLUTtransIndexID = (*env)->GetFieldID(env, cls, |
| "srcLUTtransIndex", "I")); |
| } |
| |
| /* |
| * This routine is used to draw ICM pixels into a default color model |
| */ |
| JNIEXPORT jboolean JNICALL |
| Java_sun_awt_image_ImageRepresentation_setICMpixels(JNIEnv *env, jclass cls, |
| jint x, jint y, jint w, |
| jint h, jintArray jlut, |
| jbyteArray jpix, jint off, |
| jint scansize, |
| jobject jict) |
| { |
| unsigned char *srcData = NULL; |
| jint srcDataLength; |
| int *dstData; |
| jint dstDataLength; |
| jint dstDataOff; |
| int *dstP, *dstyP; |
| unsigned char *srcyP, *srcP; |
| int *srcLUT = NULL; |
| int yIdx, xIdx; |
| int sStride; |
| int *cOffs; |
| int pixelStride; |
| jobject joffs = NULL; |
| jobject jdata = NULL; |
| |
| if (JNU_IsNull(env, jlut)) { |
| JNU_ThrowNullPointerException(env, "NullPointerException"); |
| return JNI_FALSE; |
| } |
| |
| if (JNU_IsNull(env, jpix)) { |
| JNU_ThrowNullPointerException(env, "NullPointerException"); |
| return JNI_FALSE; |
| } |
| |
| if (x < 0 || w < 1 || (0x7fffffff - x) < w) { |
| return JNI_FALSE; |
| } |
| |
| if (y < 0 || h < 1 || (0x7fffffff - y) < h) { |
| return JNI_FALSE; |
| } |
| |
| sStride = (*env)->GetIntField(env, jict, g_ICRscanstrID); |
| pixelStride = (*env)->GetIntField(env, jict, g_ICRpixstrID); |
| joffs = (*env)->GetObjectField(env, jict, g_ICRdataOffsetsID); |
| jdata = (*env)->GetObjectField(env, jict, g_ICRdataID); |
| |
| if (JNU_IsNull(env, jdata)) { |
| /* no destination buffer */ |
| return JNI_FALSE; |
| } |
| |
| if (JNU_IsNull(env, joffs) || (*env)->GetArrayLength(env, joffs) < 1) { |
| /* invalid data offstes in raster */ |
| return JNI_FALSE; |
| } |
| |
| srcDataLength = (*env)->GetArrayLength(env, jpix); |
| dstDataLength = (*env)->GetArrayLength(env, jdata); |
| |
| cOffs = (int *) (*env)->GetPrimitiveArrayCritical(env, joffs, NULL); |
| if (cOffs == NULL) { |
| (*env)->ExceptionClear(env); |
| JNU_ThrowNullPointerException(env, "Null channel offset array"); |
| return JNI_FALSE; |
| } |
| |
| dstDataOff = cOffs[0]; |
| |
| /* the offset array is not needed anymore and can be released */ |
| (*env)->ReleasePrimitiveArrayCritical(env, joffs, cOffs, JNI_ABORT); |
| joffs = NULL; |
| cOffs = NULL; |
| |
| /* do basic validation: make sure that offsets for |
| * first pixel and for last pixel are safe to calculate and use */ |
| CHECK_STRIDE(y, h, sStride); |
| CHECK_STRIDE(x, w, pixelStride); |
| |
| CHECK_DST(x, y); |
| CHECK_DST(x + w -1, y + h - 1); |
| |
| /* check source array */ |
| CHECK_SRC(); |
| |
| srcLUT = (int *) (*env)->GetPrimitiveArrayCritical(env, jlut, NULL); |
| if (srcLUT == NULL) { |
| (*env)->ExceptionClear(env); |
| JNU_ThrowNullPointerException(env, "Null IndexColorModel LUT"); |
| return JNI_FALSE; |
| } |
| |
| srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix, |
| NULL); |
| if (srcData == NULL) { |
| (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); |
| (*env)->ExceptionClear(env); |
| JNU_ThrowNullPointerException(env, "Null data array"); |
| return JNI_FALSE; |
| } |
| |
| dstData = (int *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL); |
| if (dstData == NULL) { |
| (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); |
| (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
| (*env)->ExceptionClear(env); |
| JNU_ThrowNullPointerException(env, "Null tile data array"); |
| return JNI_FALSE; |
| } |
| |
| dstyP = dstData + dstDataOff + y*sStride + x*pixelStride; |
| srcyP = srcData + off; |
| for (yIdx = 0; yIdx < h; yIdx++, srcyP += scansize, dstyP+=sStride) { |
| srcP = srcyP; |
| dstP = dstyP; |
| for (xIdx = 0; xIdx < w; xIdx++, dstP+=pixelStride) { |
| *dstP = srcLUT[*srcP++]; |
| } |
| } |
| |
| /* Release the locked arrays */ |
| (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); |
| (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
| (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT); |
| |
| return JNI_TRUE; |
| } |
| |
| JNIEXPORT jboolean JNICALL |
| Java_sun_awt_image_ImageRepresentation_setDiffICM(JNIEnv *env, jclass cls, |
| jint x, jint y, jint w, |
| jint h, jintArray jlut, |
| jint transIdx, jint numLut, |
| jobject jicm, |
| jbyteArray jpix, jint off, |
| jint scansize, |
| jobject jbct, jint dstDataOff) |
| { |
| unsigned int *srcLUT = NULL; |
| unsigned int *newLUT = NULL; |
| int sStride; |
| int pixelStride; |
| int mapSize; |
| jobject jdata = NULL; |
| jobject jnewlut = NULL; |
| jint srcDataLength; |
| jint dstDataLength; |
| unsigned char *srcData; |
| unsigned char *dstData; |
| unsigned char *dataP; |
| unsigned char *pixP; |
| int i; |
| int j; |
| int newNumLut; |
| int newTransIdx; |
| int jniFlag = JNI_ABORT; |
| unsigned char *ydataP; |
| unsigned char *ypixP; |
| unsigned char cvtLut[256]; |
| |
| if (JNU_IsNull(env, jlut)) { |
| JNU_ThrowNullPointerException(env, "NullPointerException"); |
| return JNI_FALSE; |
| } |
| |
| if (JNU_IsNull(env, jpix)) { |
| JNU_ThrowNullPointerException(env, "NullPointerException"); |
| return JNI_FALSE; |
| } |
| |
| if (x < 0 || w < 1 || (0x7fffffff - x) < w) { |
| return JNI_FALSE; |
| } |
| |
| if (y < 0 || h < 1 || (0x7fffffff - y) < h) { |
| return JNI_FALSE; |
| } |
| |
| |
| sStride = (*env)->GetIntField(env, jbct, g_BCRscanstrID); |
| pixelStride =(*env)->GetIntField(env, jbct, g_BCRpixstrID); |
| jdata = (*env)->GetObjectField(env, jbct, g_BCRdataID); |
| jnewlut = (*env)->GetObjectField(env, jicm, g_ICMrgbID); |
| mapSize = (*env)->GetIntField(env, jicm, g_ICMmapSizeID); |
| |
| if (numLut < 0 || numLut > 256 || mapSize < 0 || mapSize > 256) { |
| /* Ether old or new ICM has a palette that exceeds capacity |
| of byte data type, so we have to convert the image data |
| to default representation. |
| */ |
| return JNI_FALSE; |
| } |
| |
| if (JNU_IsNull(env, jdata)) { |
| /* no destination buffer */ |
| return JNI_FALSE; |
| } |
| |
| srcDataLength = (*env)->GetArrayLength(env, jpix); |
| dstDataLength = (*env)->GetArrayLength(env, jdata); |
| |
| CHECK_STRIDE(y, h, sStride); |
| CHECK_STRIDE(x, w, pixelStride); |
| |
| CHECK_DST(x, y); |
| CHECK_DST(x + w -1, y + h - 1); |
| |
| /* check source array */ |
| CHECK_SRC(); |
| |
| srcLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jlut, |
| NULL); |
| if (srcLUT == NULL) { |
| /* out of memory error already thrown */ |
| return JNI_FALSE; |
| } |
| |
| newLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jnewlut, |
| NULL); |
| if (newLUT == NULL) { |
| (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, |
| JNI_ABORT); |
| /* out of memory error already thrown */ |
| return JNI_FALSE; |
| } |
| |
| newNumLut = numLut; |
| newTransIdx = transIdx; |
| if (compareLUTs(srcLUT, numLut, transIdx, newLUT, mapSize, |
| cvtLut, &newNumLut, &newTransIdx, &jniFlag) == FALSE) { |
| /* Need to convert to ICR */ |
| (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, |
| JNI_ABORT); |
| (*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT); |
| return JNI_FALSE; |
| } |
| |
| /* Don't need these any more */ |
| (*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, jniFlag); |
| (*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT); |
| |
| if (newNumLut != numLut) { |
| /* Need to write back new number of entries in lut */ |
| (*env)->SetIntField(env, cls, s_JnumSrcLUTID, newNumLut); |
| } |
| |
| if (newTransIdx != transIdx) { |
| (*env)->SetIntField(env, cls, s_JsrcLUTtransIndexID, newTransIdx); |
| } |
| |
| srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix, |
| NULL); |
| if (srcData == NULL) { |
| /* out of memory error already thrown */ |
| return JNI_FALSE; |
| } |
| |
| dstData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jdata, |
| NULL); |
| if (dstData == NULL) { |
| (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
| /* out of memory error already thrown */ |
| return JNI_FALSE; |
| } |
| |
| ydataP = dstData + dstDataOff + y*sStride + x*pixelStride; |
| ypixP = srcData + off; |
| |
| for (i=0; i < h; i++) { |
| dataP = ydataP; |
| pixP = ypixP; |
| for (j=0; j < w; j++) { |
| *dataP = cvtLut[*pixP]; |
| dataP += pixelStride; |
| pixP++; |
| } |
| ydataP += sStride; |
| ypixP += scansize; |
| } |
| |
| (*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
| (*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT); |
| |
| return JNI_TRUE; |
| } |
| |
| static int compareLUTs(unsigned int *lut1, int numLut1, int transIdx, |
| unsigned int *lut2, int numLut2, unsigned char *cvtLut, |
| int *retNumLut1, int *retTransIdx, int *jniFlagP) |
| { |
| int i; |
| int idx; |
| int newTransIdx = -1; |
| unsigned int rgb; |
| int changed = FALSE; |
| int maxSize = (numLut1 > numLut2 ? numLut1 : numLut2); |
| |
| *jniFlagP = JNI_ABORT; |
| |
| for (i=0; i < maxSize; i++) { |
| cvtLut[i] = i; |
| } |
| |
| for (i=0; i < numLut2; i++) { |
| /* If this slot in new palette is different from the |
| * same slot in current palette, then we try to find |
| * this color in other slots. On failure, add this color |
| * to current palette. |
| */ |
| if ((i >= numLut1) || |
| (lut1[i] != lut2[i])) |
| { |
| rgb = lut2[i]; |
| /* Transparent */ |
| if ((rgb & ALPHA_MASK) == 0) { |
| if (transIdx == -1) { |
| if (numLut1 < 256) { |
| cvtLut[i] = numLut1; |
| newTransIdx = i; |
| transIdx = i; |
| numLut1++; |
| changed = TRUE; |
| } |
| else { |
| return FALSE; |
| } |
| } |
| cvtLut[i] = transIdx; |
| } |
| else { |
| if ((idx = findIdx(rgb, lut1, numLut1)) == -1) { |
| if (numLut1 < 256) { |
| lut1[numLut1] = rgb; |
| cvtLut[i] = numLut1; |
| numLut1++; |
| changed = TRUE; |
| } |
| else { |
| /* Bad news... need to convert image */ |
| return FALSE; |
| } |
| } else { |
| cvtLut[i] = idx; |
| } |
| } |
| } |
| } |
| |
| if (changed) { |
| *jniFlagP = 0; |
| *retNumLut1 = numLut1; |
| if (newTransIdx != -1) { |
| *retTransIdx = newTransIdx; |
| } |
| } |
| return TRUE; |
| } |
| |
| static int findIdx(unsigned int rgb, unsigned int *lut, int numLut) { |
| int i; |
| |
| if ((rgb&0xff000000)==0) { |
| for (i=0; i < numLut; i++) { |
| if ((lut[i]&0xff000000)==0) return i; |
| } |
| } |
| else { |
| for (i=0; i < numLut; i++) { |
| if (lut[i] == rgb) return i; |
| } |
| } |
| return -1; |
| } |