--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/java.desktop/share/native/libawt/awt/image/awt_ImageRep.c Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,479 @@
+/*
+ * 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;
+}