author | erikj |
Tue, 12 Sep 2017 19:03:39 +0200 | |
changeset 47216 | 71c04702a3d5 |
parent 26751 | jdk/src/java.desktop/share/native/libawt/awt/image/awt_ImageRep.c@70bac69b37c9 |
permissions | -rw-r--r-- |
2 | 1 |
/* |
23644
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
2 |
* Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. |
2 | 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 |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 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 |
* |
|
5506 | 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. |
|
2 | 24 |
*/ |
25 |
||
26 |
#include <string.h> |
|
27 |
||
28 |
#include "jni.h" |
|
29 |
#include "jni_util.h" |
|
30 |
#include "awt_parseImage.h" |
|
31 |
#include "imageInitIDs.h" |
|
32 |
#include "sun_awt_image_ImageRepresentation.h" |
|
33 |
||
34 |
static int compareLUTs(unsigned int *lut1, int numLut1, int transIdx, |
|
35 |
unsigned int *lut2, int numLut2, unsigned char *cvtLut, |
|
36 |
int *retNumLut1, int *retTransIdx, int *jniFlagP); |
|
37 |
||
38 |
static int findIdx(unsigned int rgb, unsigned int *lut, int numLut1); |
|
39 |
||
40 |
#define ALPHA_MASK 0xff000000 |
|
41 |
#ifndef FALSE |
|
42 |
# define FALSE 0 |
|
43 |
#endif |
|
44 |
#ifndef TRUE |
|
45 |
# define TRUE 1 |
|
46 |
#endif |
|
47 |
||
16880 | 48 |
#define CHECK_STRIDE(yy, hh, ss) \ |
49 |
if ((ss) != 0) { \ |
|
50 |
int limit = 0x7fffffff / ((ss) > 0 ? (ss) : -(ss)); \ |
|
51 |
if (limit < (yy) || limit < ((yy) + (hh) - 1)) { \ |
|
52 |
/* integer oveflow */ \ |
|
53 |
return JNI_FALSE; \ |
|
54 |
} \ |
|
55 |
} \ |
|
56 |
||
57 |
#define CHECK_SRC() \ |
|
58 |
do { \ |
|
59 |
int pixeloffset; \ |
|
60 |
if (off < 0 || off >= srcDataLength) { \ |
|
61 |
return JNI_FALSE; \ |
|
62 |
} \ |
|
63 |
CHECK_STRIDE(0, h, scansize); \ |
|
64 |
\ |
|
65 |
/* check scansize */ \ |
|
66 |
pixeloffset = scansize * (h - 1); \ |
|
67 |
if ((w - 1) > (0x7fffffff - pixeloffset)) { \ |
|
68 |
return JNI_FALSE; \ |
|
69 |
} \ |
|
70 |
pixeloffset += (w - 1); \ |
|
71 |
\ |
|
72 |
if (off > (0x7fffffff - pixeloffset)) { \ |
|
73 |
return JNI_FALSE; \ |
|
74 |
} \ |
|
75 |
} while (0) \ |
|
76 |
||
77 |
#define CHECK_DST(xx, yy) \ |
|
78 |
do { \ |
|
79 |
int soffset = (yy) * sStride; \ |
|
80 |
int poffset = (xx) * pixelStride; \ |
|
81 |
if (poffset > (0x7fffffff - soffset)) { \ |
|
82 |
return JNI_FALSE; \ |
|
83 |
} \ |
|
84 |
poffset += soffset; \ |
|
85 |
if (dstDataOff > (0x7fffffff - poffset)) { \ |
|
86 |
return JNI_FALSE; \ |
|
87 |
} \ |
|
88 |
poffset += dstDataOff; \ |
|
89 |
\ |
|
90 |
if (poffset < 0 || poffset >= dstDataLength) { \ |
|
91 |
return JNI_FALSE; \ |
|
92 |
} \ |
|
93 |
} while (0) \ |
|
94 |
||
2 | 95 |
static jfieldID s_JnumSrcLUTID; |
96 |
static jfieldID s_JsrcLUTtransIndexID; |
|
97 |
||
98 |
JNIEXPORT void JNICALL |
|
99 |
Java_sun_awt_image_ImageRepresentation_initIDs(JNIEnv *env, jclass cls) { |
|
23644
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
100 |
CHECK_NULL(s_JnumSrcLUTID = (*env)->GetFieldID(env, cls, "numSrcLUT", "I")); |
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
101 |
CHECK_NULL(s_JsrcLUTtransIndexID = (*env)->GetFieldID(env, cls, |
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
102 |
"srcLUTtransIndex", "I")); |
2 | 103 |
} |
104 |
||
105 |
/* |
|
106 |
* This routine is used to draw ICM pixels into a default color model |
|
107 |
*/ |
|
16880 | 108 |
JNIEXPORT jboolean JNICALL |
2 | 109 |
Java_sun_awt_image_ImageRepresentation_setICMpixels(JNIEnv *env, jclass cls, |
110 |
jint x, jint y, jint w, |
|
111 |
jint h, jintArray jlut, |
|
112 |
jbyteArray jpix, jint off, |
|
113 |
jint scansize, |
|
114 |
jobject jict) |
|
115 |
{ |
|
116 |
unsigned char *srcData = NULL; |
|
16880 | 117 |
jint srcDataLength; |
2 | 118 |
int *dstData; |
16880 | 119 |
jint dstDataLength; |
120 |
jint dstDataOff; |
|
2 | 121 |
int *dstP, *dstyP; |
122 |
unsigned char *srcyP, *srcP; |
|
123 |
int *srcLUT = NULL; |
|
124 |
int yIdx, xIdx; |
|
125 |
int sStride; |
|
126 |
int *cOffs; |
|
127 |
int pixelStride; |
|
128 |
jobject joffs = NULL; |
|
129 |
jobject jdata = NULL; |
|
130 |
||
131 |
if (JNU_IsNull(env, jlut)) { |
|
132 |
JNU_ThrowNullPointerException(env, "NullPointerException"); |
|
16880 | 133 |
return JNI_FALSE; |
2 | 134 |
} |
135 |
||
136 |
if (JNU_IsNull(env, jpix)) { |
|
137 |
JNU_ThrowNullPointerException(env, "NullPointerException"); |
|
16880 | 138 |
return JNI_FALSE; |
139 |
} |
|
140 |
||
141 |
if (x < 0 || w < 1 || (0x7fffffff - x) < w) { |
|
142 |
return JNI_FALSE; |
|
143 |
} |
|
144 |
||
145 |
if (y < 0 || h < 1 || (0x7fffffff - y) < h) { |
|
146 |
return JNI_FALSE; |
|
2 | 147 |
} |
148 |
||
149 |
sStride = (*env)->GetIntField(env, jict, g_ICRscanstrID); |
|
150 |
pixelStride = (*env)->GetIntField(env, jict, g_ICRpixstrID); |
|
151 |
joffs = (*env)->GetObjectField(env, jict, g_ICRdataOffsetsID); |
|
152 |
jdata = (*env)->GetObjectField(env, jict, g_ICRdataID); |
|
153 |
||
16880 | 154 |
if (JNU_IsNull(env, jdata)) { |
155 |
/* no destination buffer */ |
|
156 |
return JNI_FALSE; |
|
157 |
} |
|
158 |
||
159 |
if (JNU_IsNull(env, joffs) || (*env)->GetArrayLength(env, joffs) < 1) { |
|
160 |
/* invalid data offstes in raster */ |
|
161 |
return JNI_FALSE; |
|
162 |
} |
|
163 |
||
164 |
srcDataLength = (*env)->GetArrayLength(env, jpix); |
|
165 |
dstDataLength = (*env)->GetArrayLength(env, jdata); |
|
166 |
||
167 |
cOffs = (int *) (*env)->GetPrimitiveArrayCritical(env, joffs, NULL); |
|
168 |
if (cOffs == NULL) { |
|
23644
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
169 |
(*env)->ExceptionClear(env); |
16880 | 170 |
JNU_ThrowNullPointerException(env, "Null channel offset array"); |
171 |
return JNI_FALSE; |
|
172 |
} |
|
173 |
||
174 |
dstDataOff = cOffs[0]; |
|
175 |
||
176 |
/* the offset array is not needed anymore and can be released */ |
|
177 |
(*env)->ReleasePrimitiveArrayCritical(env, joffs, cOffs, JNI_ABORT); |
|
178 |
joffs = NULL; |
|
179 |
cOffs = NULL; |
|
180 |
||
181 |
/* do basic validation: make sure that offsets for |
|
182 |
* first pixel and for last pixel are safe to calculate and use */ |
|
183 |
CHECK_STRIDE(y, h, sStride); |
|
184 |
CHECK_STRIDE(x, w, pixelStride); |
|
185 |
||
186 |
CHECK_DST(x, y); |
|
187 |
CHECK_DST(x + w -1, y + h - 1); |
|
188 |
||
189 |
/* check source array */ |
|
190 |
CHECK_SRC(); |
|
191 |
||
2 | 192 |
srcLUT = (int *) (*env)->GetPrimitiveArrayCritical(env, jlut, NULL); |
193 |
if (srcLUT == NULL) { |
|
23644
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
194 |
(*env)->ExceptionClear(env); |
2 | 195 |
JNU_ThrowNullPointerException(env, "Null IndexColorModel LUT"); |
16880 | 196 |
return JNI_FALSE; |
2 | 197 |
} |
198 |
||
199 |
srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix, |
|
200 |
NULL); |
|
201 |
if (srcData == NULL) { |
|
202 |
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); |
|
23644
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
203 |
(*env)->ExceptionClear(env); |
2 | 204 |
JNU_ThrowNullPointerException(env, "Null data array"); |
16880 | 205 |
return JNI_FALSE; |
2 | 206 |
} |
207 |
||
208 |
dstData = (int *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL); |
|
209 |
if (dstData == NULL) { |
|
210 |
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); |
|
211 |
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
|
23644
0cdb97daeef5
8030787: [Parfait] JNI-related warnings from b119 for jdk/src/share/native/sun/awt/image
pchelko
parents:
23010
diff
changeset
|
212 |
(*env)->ExceptionClear(env); |
2 | 213 |
JNU_ThrowNullPointerException(env, "Null tile data array"); |
16880 | 214 |
return JNI_FALSE; |
2 | 215 |
} |
216 |
||
16880 | 217 |
dstyP = dstData + dstDataOff + y*sStride + x*pixelStride; |
2 | 218 |
srcyP = srcData + off; |
219 |
for (yIdx = 0; yIdx < h; yIdx++, srcyP += scansize, dstyP+=sStride) { |
|
220 |
srcP = srcyP; |
|
221 |
dstP = dstyP; |
|
222 |
for (xIdx = 0; xIdx < w; xIdx++, dstP+=pixelStride) { |
|
223 |
*dstP = srcLUT[*srcP++]; |
|
224 |
} |
|
225 |
} |
|
226 |
||
227 |
/* Release the locked arrays */ |
|
228 |
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT); |
|
229 |
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
|
230 |
(*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT); |
|
231 |
||
16880 | 232 |
return JNI_TRUE; |
2 | 233 |
} |
234 |
||
16880 | 235 |
JNIEXPORT jboolean JNICALL |
2 | 236 |
Java_sun_awt_image_ImageRepresentation_setDiffICM(JNIEnv *env, jclass cls, |
237 |
jint x, jint y, jint w, |
|
238 |
jint h, jintArray jlut, |
|
239 |
jint transIdx, jint numLut, |
|
240 |
jobject jicm, |
|
241 |
jbyteArray jpix, jint off, |
|
242 |
jint scansize, |
|
16880 | 243 |
jobject jbct, jint dstDataOff) |
2 | 244 |
{ |
245 |
unsigned int *srcLUT = NULL; |
|
246 |
unsigned int *newLUT = NULL; |
|
247 |
int sStride; |
|
248 |
int pixelStride; |
|
249 |
int mapSize; |
|
250 |
jobject jdata = NULL; |
|
251 |
jobject jnewlut = NULL; |
|
16880 | 252 |
jint srcDataLength; |
253 |
jint dstDataLength; |
|
2 | 254 |
unsigned char *srcData; |
255 |
unsigned char *dstData; |
|
256 |
unsigned char *dataP; |
|
257 |
unsigned char *pixP; |
|
258 |
int i; |
|
259 |
int j; |
|
260 |
int newNumLut; |
|
261 |
int newTransIdx; |
|
262 |
int jniFlag = JNI_ABORT; |
|
263 |
unsigned char *ydataP; |
|
264 |
unsigned char *ypixP; |
|
265 |
unsigned char cvtLut[256]; |
|
266 |
||
267 |
if (JNU_IsNull(env, jlut)) { |
|
268 |
JNU_ThrowNullPointerException(env, "NullPointerException"); |
|
16880 | 269 |
return JNI_FALSE; |
2 | 270 |
} |
271 |
||
272 |
if (JNU_IsNull(env, jpix)) { |
|
273 |
JNU_ThrowNullPointerException(env, "NullPointerException"); |
|
16880 | 274 |
return JNI_FALSE; |
275 |
} |
|
276 |
||
277 |
if (x < 0 || w < 1 || (0x7fffffff - x) < w) { |
|
278 |
return JNI_FALSE; |
|
2 | 279 |
} |
280 |
||
16880 | 281 |
if (y < 0 || h < 1 || (0x7fffffff - y) < h) { |
282 |
return JNI_FALSE; |
|
283 |
} |
|
284 |
||
285 |
||
2 | 286 |
sStride = (*env)->GetIntField(env, jbct, g_BCRscanstrID); |
287 |
pixelStride =(*env)->GetIntField(env, jbct, g_BCRpixstrID); |
|
288 |
jdata = (*env)->GetObjectField(env, jbct, g_BCRdataID); |
|
289 |
jnewlut = (*env)->GetObjectField(env, jicm, g_ICMrgbID); |
|
290 |
mapSize = (*env)->GetIntField(env, jicm, g_ICMmapSizeID); |
|
291 |
||
4202 | 292 |
if (numLut < 0 || numLut > 256 || mapSize < 0 || mapSize > 256) { |
293 |
/* Ether old or new ICM has a palette that exceeds capacity |
|
294 |
of byte data type, so we have to convert the image data |
|
295 |
to default representation. |
|
296 |
*/ |
|
16880 | 297 |
return JNI_FALSE; |
298 |
} |
|
299 |
||
300 |
if (JNU_IsNull(env, jdata)) { |
|
301 |
/* no destination buffer */ |
|
302 |
return JNI_FALSE; |
|
4202 | 303 |
} |
16880 | 304 |
|
305 |
srcDataLength = (*env)->GetArrayLength(env, jpix); |
|
306 |
dstDataLength = (*env)->GetArrayLength(env, jdata); |
|
307 |
||
308 |
CHECK_STRIDE(y, h, sStride); |
|
309 |
CHECK_STRIDE(x, w, pixelStride); |
|
310 |
||
311 |
CHECK_DST(x, y); |
|
312 |
CHECK_DST(x + w -1, y + h - 1); |
|
313 |
||
314 |
/* check source array */ |
|
315 |
CHECK_SRC(); |
|
316 |
||
2 | 317 |
srcLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jlut, |
318 |
NULL); |
|
319 |
if (srcLUT == NULL) { |
|
320 |
/* out of memory error already thrown */ |
|
16880 | 321 |
return JNI_FALSE; |
2 | 322 |
} |
323 |
||
324 |
newLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jnewlut, |
|
325 |
NULL); |
|
326 |
if (newLUT == NULL) { |
|
327 |
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, |
|
328 |
JNI_ABORT); |
|
329 |
/* out of memory error already thrown */ |
|
16880 | 330 |
return JNI_FALSE; |
2 | 331 |
} |
332 |
||
333 |
newNumLut = numLut; |
|
334 |
newTransIdx = transIdx; |
|
335 |
if (compareLUTs(srcLUT, numLut, transIdx, newLUT, mapSize, |
|
336 |
cvtLut, &newNumLut, &newTransIdx, &jniFlag) == FALSE) { |
|
337 |
/* Need to convert to ICR */ |
|
338 |
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, |
|
339 |
JNI_ABORT); |
|
340 |
(*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT); |
|
16880 | 341 |
return JNI_FALSE; |
2 | 342 |
} |
343 |
||
344 |
/* Don't need these any more */ |
|
345 |
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, jniFlag); |
|
346 |
(*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT); |
|
347 |
||
348 |
if (newNumLut != numLut) { |
|
349 |
/* Need to write back new number of entries in lut */ |
|
350 |
(*env)->SetIntField(env, cls, s_JnumSrcLUTID, newNumLut); |
|
351 |
} |
|
352 |
||
353 |
if (newTransIdx != transIdx) { |
|
354 |
(*env)->SetIntField(env, cls, s_JsrcLUTtransIndexID, newTransIdx); |
|
355 |
} |
|
356 |
||
357 |
srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix, |
|
358 |
NULL); |
|
359 |
if (srcData == NULL) { |
|
360 |
/* out of memory error already thrown */ |
|
16880 | 361 |
return JNI_FALSE; |
2 | 362 |
} |
363 |
||
364 |
dstData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jdata, |
|
365 |
NULL); |
|
366 |
if (dstData == NULL) { |
|
367 |
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
|
368 |
/* out of memory error already thrown */ |
|
16880 | 369 |
return JNI_FALSE; |
2 | 370 |
} |
371 |
||
16880 | 372 |
ydataP = dstData + dstDataOff + y*sStride + x*pixelStride; |
2 | 373 |
ypixP = srcData + off; |
374 |
||
375 |
for (i=0; i < h; i++) { |
|
376 |
dataP = ydataP; |
|
377 |
pixP = ypixP; |
|
378 |
for (j=0; j < w; j++) { |
|
379 |
*dataP = cvtLut[*pixP]; |
|
380 |
dataP += pixelStride; |
|
381 |
pixP++; |
|
382 |
} |
|
383 |
ydataP += sStride; |
|
384 |
ypixP += scansize; |
|
385 |
} |
|
386 |
||
387 |
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT); |
|
388 |
(*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT); |
|
389 |
||
16880 | 390 |
return JNI_TRUE; |
2 | 391 |
} |
392 |
||
393 |
static int compareLUTs(unsigned int *lut1, int numLut1, int transIdx, |
|
394 |
unsigned int *lut2, int numLut2, unsigned char *cvtLut, |
|
395 |
int *retNumLut1, int *retTransIdx, int *jniFlagP) |
|
396 |
{ |
|
397 |
int i; |
|
398 |
int idx; |
|
399 |
int newTransIdx = -1; |
|
400 |
unsigned int rgb; |
|
401 |
int changed = FALSE; |
|
402 |
int maxSize = (numLut1 > numLut2 ? numLut1 : numLut2); |
|
403 |
||
404 |
*jniFlagP = JNI_ABORT; |
|
405 |
||
406 |
for (i=0; i < maxSize; i++) { |
|
407 |
cvtLut[i] = i; |
|
408 |
} |
|
409 |
||
410 |
for (i=0; i < numLut2; i++) { |
|
411 |
/* If this slot in new palette is different from the |
|
412 |
* same slot in current palette, then we try to find |
|
413 |
* this color in other slots. On failure, add this color |
|
414 |
* to current palette. |
|
415 |
*/ |
|
416 |
if ((i >= numLut1) || |
|
417 |
(lut1[i] != lut2[i])) |
|
418 |
{ |
|
419 |
rgb = lut2[i]; |
|
420 |
/* Transparent */ |
|
421 |
if ((rgb & ALPHA_MASK) == 0) { |
|
422 |
if (transIdx == -1) { |
|
423 |
if (numLut1 < 256) { |
|
424 |
cvtLut[i] = numLut1; |
|
425 |
newTransIdx = i; |
|
426 |
transIdx = i; |
|
427 |
numLut1++; |
|
428 |
changed = TRUE; |
|
429 |
} |
|
430 |
else { |
|
431 |
return FALSE; |
|
432 |
} |
|
433 |
} |
|
434 |
cvtLut[i] = transIdx; |
|
435 |
} |
|
436 |
else { |
|
437 |
if ((idx = findIdx(rgb, lut1, numLut1)) == -1) { |
|
438 |
if (numLut1 < 256) { |
|
439 |
lut1[numLut1] = rgb; |
|
440 |
cvtLut[i] = numLut1; |
|
441 |
numLut1++; |
|
442 |
changed = TRUE; |
|
443 |
} |
|
444 |
else { |
|
445 |
/* Bad news... need to convert image */ |
|
446 |
return FALSE; |
|
447 |
} |
|
448 |
} else { |
|
449 |
cvtLut[i] = idx; |
|
450 |
} |
|
451 |
} |
|
452 |
} |
|
453 |
} |
|
454 |
||
455 |
if (changed) { |
|
456 |
*jniFlagP = 0; |
|
457 |
*retNumLut1 = numLut1; |
|
458 |
if (newTransIdx != -1) { |
|
459 |
*retTransIdx = newTransIdx; |
|
460 |
} |
|
461 |
} |
|
462 |
return TRUE; |
|
463 |
} |
|
464 |
||
465 |
static int findIdx(unsigned int rgb, unsigned int *lut, int numLut) { |
|
466 |
int i; |
|
467 |
||
468 |
if ((rgb&0xff000000)==0) { |
|
469 |
for (i=0; i < numLut; i++) { |
|
470 |
if ((lut[i]&0xff000000)==0) return i; |
|
471 |
} |
|
472 |
} |
|
473 |
else { |
|
474 |
for (i=0; i < numLut; i++) { |
|
475 |
if (lut[i] == rgb) return i; |
|
476 |
} |
|
477 |
} |
|
478 |
return -1; |
|
479 |
} |