Bug Summary

File:jdk/src/java.desktop/share/native/libawt/awt/medialib/awt_ImagingLib.c
Warning:line 3439, column 87
The right operand of '>>' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name awt_ImagingLib.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -D __MEDIALIB_OLD_NAMES -D __USE_J2D_NAMES -D MLIB_NO_LIBSUNMATH -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/libawt -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/common/awt/debug -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/common/awt -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.desktop -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/image -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/image/cvutils -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/libawt/java2d -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d/loops -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/java2d/pipe -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.base -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/medialib -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/common/awt/medialib -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libmlib_image -I /home/daniel/Projects/java/jdk/src/java.desktop/unix/native/include -I /home/daniel/Projects/java/jdk/src/java.desktop/share/native/include -I /home/daniel/Projects/java/jdk/src/java.base/linux/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/include -I /home/daniel/Projects/java/jdk/src/java.base/share/native/include -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-unused -Wno-sign-compare -Wno-unused-result -Wno-maybe-uninitialized -Wno-format-nonliteral -Wno-parentheses -Wno-unused-value -Wno-unused-function -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility default -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.desktop/share/native/libawt/awt/medialib/awt_ImagingLib.c
1/*
2 * Copyright (c) 1997, 2016, 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 <string.h>
29#include "sun_awt_image_ImagingLib.h"
30#include "java_awt_Transparency.h"
31#include "java_awt_image_AffineTransformOp.h"
32#include "java_awt_image_BufferedImage.h"
33#include "java_awt_color_ColorSpace.h"
34#include "java_awt_image_ConvolveOp.h"
35#include "sun_awt_image_IntegerComponentRaster.h"
36#include "awt_ImagingLib.h"
37#include "awt_parseImage.h"
38#include "imageInitIDs.h"
39#include <jni.h>
40#include <jni_util.h>
41#include <assert.h>
42#include "awt_Mlib.h"
43#include "gdefs.h"
44#include "safe_alloc.h"
45#include "safe_math.h"
46
47/***************************************************************************
48 * Definitions *
49 ***************************************************************************/
50#define jio_fprintffprintf fprintf
51
52#ifndef TRUE(1)
53#define TRUE(1) 1
54#endif /* TRUE */
55
56#ifndef FALSE(0)
57#define FALSE(0) 0
58#endif /* FALSE */
59
60#define TYPE_CUSTOM0L java_awt_image_BufferedImage_TYPE_CUSTOM0L
61#define TYPE_INT_RGB1L java_awt_image_BufferedImage_TYPE_INT_RGB1L
62#define TYPE_INT_ARGB2L java_awt_image_BufferedImage_TYPE_INT_ARGB2L
63#define TYPE_INT_ARGB_PRE3L java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE3L
64#define TYPE_INT_BGR4L java_awt_image_BufferedImage_TYPE_INT_BGR4L
65#define TYPE_4BYTE_ABGR6L java_awt_image_BufferedImage_TYPE_4BYTE_ABGR6L
66#define TYPE_4BYTE_ABGR_PRE7L java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE7L
67
68/* (alpha*color)>>nbits + alpha>>(nbits-1) */
69#define BLEND(color, alpha, alphaNbits)((((alpha)*(color))>>(alphaNbits)) + ((alpha) >> (
(alphaNbits)-1))) \
70 ((((alpha)*(color))>>(alphaNbits)) + ((alpha) >> ((alphaNbits)-1)))
71
72 /* ((color - (alpha>>(nBits-1)))<<nBits)/alpha */
73#define UNBLEND(color, alpha, alphaNbits)((((color)-((alpha)>>((alphaNbits)-1)))<<(alphaNbits
))/(alpha)) \
74 ((((color)-((alpha)>>((alphaNbits)-1)))<<(alphaNbits))/(alpha))
75
76/* Enumeration of all of the mlib functions used */
77typedef enum {
78 MLIB_CONVMxN,
79 MLIB_AFFINE,
80 MLIB_LOOKUP,
81 MLIB_CONVKERNCVT
82} mlibTypeE_t;
83
84typedef struct {
85 int dataType; /* One of BYTE_DATA_TYPE, SHORT_DATA_TYPE, */
86 int needToCopy;
87 int cvtSrcToDefault; /* If TRUE, convert the src to def CM (pre?) */
88 int allocDefaultDst; /* If TRUE, alloc def CM dst buffer */
89 int cvtToDst; /* If TRUE, convert dst buffer to Dst CM */
90 int addAlpha;
91} mlibHintS_t;
92
93/***************************************************************************
94 * Static Variables/Structures *
95 ***************************************************************************/
96
97static mlibSysFnS_t sMlibSysFns = {
98 NULL((void*)0), // placeholder for j2d_mlib_ImageCreate
99 NULL((void*)0), // placeholder for j2d_mlib_ImageCreateStruct
100 NULL((void*)0), // placeholder for j2d_mlib_ImageDelete
101};
102
103static mlibFnS_t sMlibFns[] = {
104 {NULL((void*)0), "j2d_mlib_ImageConvMxN"},
105 {NULL((void*)0), "j2d_mlib_ImageAffine"},
106 {NULL((void*)0), "j2d_mlib_ImageLookUp"},
107 {NULL((void*)0), "j2d_mlib_ImageConvKernelConvert"},
108 {NULL((void*)0), NULL((void*)0)},
109};
110
111static int s_timeIt = 0;
112static int s_printIt = 0;
113static int s_startOff = 0;
114static int s_nomlib = 0;
115
116/***************************************************************************
117 * Static Function Prototypes *
118 ***************************************************************************/
119
120static int
121allocateArray(JNIEnv *env, BufImageS_t *imageP,
122 mlib_image **mlibImagePP, void **dataPP, int isSrc,
123 int cvtToDefault, int addAlpha);
124static int
125allocateRasterArray(JNIEnv *env, RasterS_t *rasterP,
126 mlib_image **mlibImagePP, void **dataPP, int isSrc);
127
128static void
129freeArray(JNIEnv *env, BufImageS_t *srcimageP, mlib_image *srcmlibImP,
130 void *srcdataP, BufImageS_t *dstimageP, mlib_image *dstmlibImP,
131 void *dstdataP);
132static void
133freeDataArray(JNIEnv *env, jobject srcJdata, mlib_image *srcmlibImP,
134 void *srcdataP, jobject dstJdata, mlib_image *dstmlibImP,
135 void *dstdataP);
136
137static int
138storeImageArray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
139 mlib_image *mlibImP);
140
141static int
142storeRasterArray(JNIEnv *env, RasterS_t *srcP, RasterS_t *dstP,
143 mlib_image *mlibImP);
144
145static int
146storeICMarray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
147 mlib_image *mlibImP);
148
149static int
150colorMatch(int r, int g, int b, int a, unsigned char *argb, int numColors);
151
152static int
153setImageHints(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
154 int expandICM, int useAlpha,
155 int premultiply, mlibHintS_t *hintP);
156
157
158static int expandICM(JNIEnv *env, BufImageS_t *imageP, unsigned int *mDataP);
159static int expandPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
160 unsigned char *outDataP);
161static int expandPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
162 unsigned char *outDataP);
163static int expandPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
164 unsigned char *outDataP);
165static int expandPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
166 int component, unsigned char *outDataP,
167 int forceAlpha);
168static int expandPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
169 int component, unsigned char *outDataP,
170 int forceAlpha);
171static int expandPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
172 int component, unsigned char *outDataP,
173 int forceAlpha);
174static int setPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
175 unsigned char *outDataP);
176static int setPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
177 unsigned char *outDataP);
178static int setPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
179 unsigned char *outDataP);
180static int setPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
181 int component, unsigned char *outDataP,
182 int supportsAlpha);
183static int setPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
184 int component, unsigned char *outDataP,
185 int supportsAlpha);
186static int setPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
187 int component, unsigned char *outDataP,
188 int supportsAlpha);
189
190mlib_start_timer start_timer = NULL((void*)0);
191mlib_stop_timer stop_timer = NULL((void*)0);
192
193/***************************************************************************
194 * Debugging Definitions *
195 ***************************************************************************/
196#ifdef DEBUG1
197
198static void
199printMedialibError(int status) {
200 switch(status) {
201 case MLIB_FAILURE:
202 jio_fprintf(stderr, "failure\n")__fprintf_chk (stderr, 2 - 1, "failure\n");
203 break;
204 case MLIB_NULLPOINTER:
205 jio_fprintf(stderr, "null pointer\n")__fprintf_chk (stderr, 2 - 1, "null pointer\n");
206 break;
207 case MLIB_OUTOFRANGE:
208 jio_fprintf (stderr, "out of range\n")__fprintf_chk (stderr, 2 - 1, "out of range\n");
209 break;
210 default:
211 jio_fprintf (stderr, "medialib error\n")__fprintf_chk (stderr, 2 - 1, "medialib error\n");
212 break;
213 }
214}
215#else /* ! DEBUG */
216# define printMedialibError(x)
217
218#endif /* ! DEBUG */
219
220static int
221getMlibEdgeHint(jint edgeHint) {
222 switch (edgeHint) {
223 case java_awt_image_ConvolveOp_EDGE_NO_OP1L:
224 return MLIB_EDGE_DST_COPY_SRC;
225 case java_awt_image_ConvolveOp_EDGE_ZERO_FILL0L:
226 default:
227 return MLIB_EDGE_DST_FILL_ZERO;
228 }
229}
230
231/*
232 * We have to make sure that awt_setPixels can be safely applied to the given pair of
233 * raster and mlib image.
234 *
235 * In particular, make sure that
236 * - dimension is the same
237 * - number of channels in mlib image corresponds to the number of bands in the raster
238 * - sample size in image and raster are the same.
239 *
240 * Returns:
241 * -1 to indicate failure,
242 * 1 to indicate success
243 */
244static int setPixelsFormMlibImage(JNIEnv *env, RasterS_t *rasterP, mlib_image* img) {
245 if (rasterP->width != img->width || rasterP->height != img->height) {
246 /* dimension does not match */
247 return -1;
248 }
249
250 if (rasterP->numBands != img->channels) {
251 /* number of bands does not match */
252 return -1;
253 }
254
255 switch (rasterP->dataType) {
256 case BYTE_DATA_TYPE1:
257 if (img->type != MLIB_BYTE) {
258 return -1;
259 }
260 break;
261 case SHORT_DATA_TYPE2:
262 if (img->type != MLIB_SHORT && img->type != MLIB_USHORT) {
263 return -1;
264 }
265 break;
266 default:
267 /* awt_setPixels does not support such rasters */
268 return -1;
269 }
270
271 return awt_setPixels(env, rasterP, mlib_ImageGetData(img));
272}
273
274/***************************************************************************
275 * External Functions *
276 ***************************************************************************/
277JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
278Java_sun_awt_image_ImagingLib_convolveBI(JNIEnv *env, jobject this,
279 jobject jsrc, jobject jdst,
280 jobject jkernel, jint edgeHint)
281{
282 void *sdata, *ddata;
283 mlib_image *src;
284 mlib_image *dst;
285 int i, scale;
286 mlib_d64 *dkern;
287 mlib_s32 *kdata;
288 int klen;
289 float kmax;
290 mlib_s32 cmask;
291 mlib_status status;
292 int retStatus = 1;
293 float *kern;
294 BufImageS_t *srcImageP, *dstImageP;
295 jobject jdata;
296 int kwidth;
297 int kheight;
298 int w, h;
299 int x, y;
300 mlibHintS_t hint;
301 int nbands;
302
303 /* This function requires a lot of local refs ??? Is 64 enough ??? */
304 if ((*env)->EnsureLocalCapacity(env, 64) < 0)
305 return 0;
306
307 if (s_nomlib) return 0;
308 if (s_timeIt) (*start_timer)(3600);
309
310 kwidth = (*env)->GetIntField(env, jkernel, g_KernelWidthID);
311 kheight = (*env)->GetIntField(env, jkernel, g_KernelHeightID);
312 jdata = (*env)->GetObjectField(env, jkernel, g_KernelDataID);
313 klen = (*env)->GetArrayLength(env, jdata);
314 kern = (float *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL((void*)0));
315 if (kern == NULL((void*)0)) {
316 /* out of memory exception already thrown */
317 return 0;
318 }
319
320 if ((kwidth&0x1) == 0) {
321 /* Kernel has even width */
322 w = kwidth+1;
323 }
324 else {
325 w = kwidth;
326 }
327 if ((kheight&0x1) == 0) {
328 /* Kernel has even height */
329 h = kheight+1;
330 }
331 else {
332 h = kheight;
333 }
334
335 dkern = NULL((void*)0);
336 if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_d64))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_d64
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_d64))))) {
337 dkern = (mlib_d64 *)calloc(1, w * h * sizeof(mlib_d64));
338 }
339 if (dkern == NULL((void*)0)) {
340 (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);
341 return 0;
342 }
343
344 /* Need to flip and find max value of the kernel.
345 * Also, save the kernel values as mlib_d64 values.
346 * The flip is to operate correctly with medialib,
347 * which doesn't do the mathemetically correct thing,
348 * i.e. it doesn't rotate the kernel by 180 degrees.
349 * REMIND: This should perhaps be done at the Java
350 * level by ConvolveOp.
351 * REMIND: Should the max test be looking at absolute
352 * values?
353 * REMIND: What if klen != kheight * kwidth?
354 */
355 kmax = kern[klen-1];
356 i = klen-1;
357 for (y=0; y < kheight; y++) {
358 for (x=0; x < kwidth; x++, i--) {
359 dkern[y*w+x] = (mlib_d64) kern[i];
360 if (kern[i] > kmax) {
361 kmax = kern[i];
362 }
363 }
364 }
365
366 (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);
367
368 if (kmax > 1<<16) {
369 /* We can only handle 16 bit max */
370 free(dkern);
371 return 0;
372 }
373
374
375 /* Parse the source image */
376 if (awt_parseImage(env, jsrc, &srcImageP, FALSE(0)) <= 0) {
377 /* Can't handle any custom images */
378 free(dkern);
379 return 0;
380 }
381
382 /* Parse the destination image */
383 if (awt_parseImage(env, jdst, &dstImageP, FALSE(0)) <= 0) {
384 /* Can't handle any custom images */
385 awt_freeParsedImage(srcImageP, TRUE(1));
386 free(dkern);
387 return 0;
388 }
389
390 nbands = setImageHints(env, srcImageP, dstImageP, TRUE(1), TRUE(1),
391 FALSE(0), &hint);
392 if (nbands < 1) {
393 /* Can't handle any custom images */
394 awt_freeParsedImage(srcImageP, TRUE(1));
395 awt_freeParsedImage(dstImageP, TRUE(1));
396 free(dkern);
397 return 0;
398 }
399 /* Allocate the arrays */
400 if (allocateArray(env, srcImageP, &src, &sdata, TRUE(1),
401 hint.cvtSrcToDefault, hint.addAlpha) < 0) {
402 /* Must be some problem */
403 awt_freeParsedImage(srcImageP, TRUE(1));
404 awt_freeParsedImage(dstImageP, TRUE(1));
405 free(dkern);
406 return 0;
407 }
408 if (allocateArray(env, dstImageP, &dst, &ddata, FALSE(0),
409 hint.cvtToDst, FALSE(0)) < 0) {
410 /* Must be some problem */
411 freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
412 awt_freeParsedImage(srcImageP, TRUE(1));
413 awt_freeParsedImage(dstImageP, TRUE(1));
414 free(dkern);
415 return 0;
416 }
417
418 kdata = NULL((void*)0);
419 if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_s32))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_s32
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_s32))))) {
420 kdata = (mlib_s32 *)malloc(w * h * sizeof(mlib_s32));
421 }
422 if (kdata == NULL((void*)0)) {
423 freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
424 awt_freeParsedImage(srcImageP, TRUE(1));
425 awt_freeParsedImage(dstImageP, TRUE(1));
426 free(dkern);
427 return 0;
428 }
429
430 if ((*sMlibFns[MLIB_CONVKERNCVT].fptr)(kdata, &scale, dkern, w, h,
431 mlib_ImageGetType(src)) != MLIB_SUCCESS) {
432 freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
433 awt_freeParsedImage(srcImageP, TRUE(1));
434 awt_freeParsedImage(dstImageP, TRUE(1));
435 free(dkern);
436 free(kdata);
437 return 0;
438 }
439
440 if (s_printIt) {
441 fprintf(stderr, "Orig Kernel(len=%d):\n",klen)__fprintf_chk (stderr, 2 - 1, "Orig Kernel(len=%d):\n",klen);
442 for (y=kheight-1; y >= 0; y--) {
443 for (x=kwidth-1; x >= 0; x--) {
444 fprintf(stderr, "%g ", dkern[y*w+x])__fprintf_chk (stderr, 2 - 1, "%g ", dkern[y*w+x]);
445 }
446 fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
447 }
448 fprintf(stderr, "New Kernel(scale=%d):\n", scale)__fprintf_chk (stderr, 2 - 1, "New Kernel(scale=%d):\n", scale
);
449 for (y=kheight-1; y >= 0; y--) {
450 for (x=kwidth-1; x >= 0; x--) {
451 fprintf(stderr, "%d ", kdata[y*w+x])__fprintf_chk (stderr, 2 - 1, "%d ", kdata[y*w+x]);
452 }
453 fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
454 }
455 }
456
457 cmask = (1<<src->channels)-1;
458 status = (*sMlibFns[MLIB_CONVMxN].fptr)(dst, src, kdata, w, h,
459 (w-1)/2, (h-1)/2, scale, cmask,
460 getMlibEdgeHint(edgeHint));
461
462 if (status != MLIB_SUCCESS) {
463 printMedialibError(status);
464 retStatus = 0;
465 }
466
467 if (s_printIt) {
468 unsigned int *dP;
469 if (s_startOff != 0) {
470 printf("Starting at %d\n", s_startOff)__printf_chk (2 - 1, "Starting at %d\n", s_startOff);
471 }
472 if (sdata == NULL((void*)0)) {
473 dP = (unsigned int *) mlib_ImageGetData(src);
474 }
475 else {
476 dP = (unsigned int *) sdata;
477 }
478 printf("src is\n")__printf_chk (2 - 1, "src is\n");
479 for (i=0; i < 20; i++) {
480 printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
481 }
482 printf("\n")__printf_chk (2 - 1, "\n");
483 if (ddata == NULL((void*)0)) {
484 dP = (unsigned int *)mlib_ImageGetData(dst);
485 }
486 else {
487 dP = (unsigned int *) ddata;
488 }
489 printf("dst is \n")__printf_chk (2 - 1, "dst is \n");
490 for (i=0; i < 20; i++) {
491 printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
492 }
493 printf("\n")__printf_chk (2 - 1, "\n");
494 }
495
496 /* Means that we couldn't write directly into the destination buffer */
497 if (ddata == NULL((void*)0)) {
498
499 /* Need to store it back into the array */
500 if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {
501 /* Error */
502 retStatus = 0;
503 }
504 }
505
506 /* Release the pinned memory */
507 freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
508 awt_freeParsedImage(srcImageP, TRUE(1));
509 awt_freeParsedImage(dstImageP, TRUE(1));
510 free(dkern);
511 free(kdata);
512
513 if (s_timeIt) (*stop_timer)(3600, 1);
514
515 return retStatus;
516}
517
518JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
519Java_sun_awt_image_ImagingLib_convolveRaster(JNIEnv *env, jobject this,
520 jobject jsrc, jobject jdst,
521 jobject jkernel, jint edgeHint)
522{
523 mlib_image *src;
524 mlib_image *dst;
525 int i, scale;
526 mlib_d64 *dkern;
527 mlib_s32 *kdata;
528 int klen;
529 float kmax;
530 int retStatus = 1;
531 mlib_status status;
532 mlib_s32 cmask;
533 void *sdata;
534 void *ddata;
535 RasterS_t *srcRasterP;
536 RasterS_t *dstRasterP;
537 int kwidth;
538 int kheight;
539 int w, h;
540 int x, y;
541 jobject jdata;
542 float *kern;
543
544 /* This function requires a lot of local refs ??? Is 64 enough ??? */
545 if ((*env)->EnsureLocalCapacity(env, 64) < 0)
546 return 0;
547
548 if (s_nomlib) return 0;
549 if (s_timeIt) (*start_timer)(3600);
550
551 kwidth = (*env)->GetIntField(env, jkernel, g_KernelWidthID);
552 kheight = (*env)->GetIntField(env, jkernel, g_KernelHeightID);
553 jdata = (*env)->GetObjectField(env, jkernel, g_KernelDataID);
554 klen = (*env)->GetArrayLength(env, jdata);
555 kern = (float *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL((void*)0));
556 if (kern == NULL((void*)0)) {
557 /* out of memory exception already thrown */
558 return 0;
559 }
560
561 if ((kwidth&0x1) == 0) {
562 /* Kernel has even width */
563 w = kwidth+1;
564 }
565 else {
566 w = kwidth;
567 }
568 if ((kheight&0x1) == 0) {
569 /* Kernel has even height */
570 h = kheight+1;
571 }
572 else {
573 h = kheight;
574 }
575
576 dkern = NULL((void*)0);
577 if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_d64))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_d64
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_d64))))) {
578 dkern = (mlib_d64 *)calloc(1, w * h * sizeof(mlib_d64));
579 }
580 if (dkern == NULL((void*)0)) {
581 (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);
582 return 0;
583 }
584
585 /* Need to flip and find max value of the kernel.
586 * Also, save the kernel values as mlib_d64 values.
587 * The flip is to operate correctly with medialib,
588 * which doesn't do the mathemetically correct thing,
589 * i.e. it doesn't rotate the kernel by 180 degrees.
590 * REMIND: This should perhaps be done at the Java
591 * level by ConvolveOp.
592 * REMIND: Should the max test be looking at absolute
593 * values?
594 * REMIND: What if klen != kheight * kwidth?
595 */
596 kmax = kern[klen-1];
597 i = klen-1;
598 for (y=0; y < kheight; y++) {
599 for (x=0; x < kwidth; x++, i--) {
600 dkern[y*w+x] = (mlib_d64) kern[i];
601 if (kern[i] > kmax) {
602 kmax = kern[i];
603 }
604 }
605 }
606
607 (*env)->ReleasePrimitiveArrayCritical(env, jdata, kern, JNI_ABORT2);
608
609 if (kmax > 1<<16) {
610 /* We can only handle 16 bit max */
611 free(dkern);
612 return 0;
613 }
614
615 /* Parse the source image */
616 if ((srcRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
617 JNU_ThrowOutOfMemoryError(env, "Out of memory");
618 free(dkern);
619 return -1;
620 }
621
622 if ((dstRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
623 JNU_ThrowOutOfMemoryError(env, "Out of memory");
624 free(srcRasterP);
625 free(dkern);
626 return -1;
627 }
628
629 /* Parse the source raster */
630 if (awt_parseRaster(env, jsrc, srcRasterP) <= 0) {
631 /* Can't handle any custom rasters */
632 free(srcRasterP);
633 free(dstRasterP);
634 free(dkern);
635 return 0;
636 }
637
638 /* Parse the destination raster */
639 if (awt_parseRaster(env, jdst, dstRasterP) <= 0) {
640 /* Can't handle any custom images */
641 awt_freeParsedRaster(srcRasterP, TRUE(1));
642 free(dstRasterP);
643 free(dkern);
644 return 0;
645 }
646
647 /* Allocate the arrays */
648 if (allocateRasterArray(env, srcRasterP, &src, &sdata, TRUE(1)) < 0) {
649 /* Must be some problem */
650 awt_freeParsedRaster(srcRasterP, TRUE(1));
651 awt_freeParsedRaster(dstRasterP, TRUE(1));
652 free(dkern);
653 return 0;
654 }
655 if (allocateRasterArray(env, dstRasterP, &dst, &ddata, FALSE(0)) < 0) {
656 /* Must be some problem */
657 freeDataArray(env, srcRasterP->jdata, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
658 awt_freeParsedRaster(srcRasterP, TRUE(1));
659 awt_freeParsedRaster(dstRasterP, TRUE(1));
660 free(dkern);
661 return 0;
662 }
663
664 kdata = NULL((void*)0);
665 if (SAFE_TO_ALLOC_3(w, h, sizeof(mlib_s32))(((w) > 0) && ((h) > 0) && ((sizeof(mlib_s32
)) > 0) && (((0x7fffffff / (w)) / (h)) > (sizeof
(mlib_s32))))) {
666 kdata = (mlib_s32 *)malloc(w * h * sizeof(mlib_s32));
667 }
668 if (kdata == NULL((void*)0)) {
669 freeDataArray(env, srcRasterP->jdata, src, sdata,
670 dstRasterP->jdata, dst, ddata);
671 awt_freeParsedRaster(srcRasterP, TRUE(1));
672 awt_freeParsedRaster(dstRasterP, TRUE(1));
673 free(dkern);
674 return 0;
675 }
676
677 if ((*sMlibFns[MLIB_CONVKERNCVT].fptr)(kdata, &scale, dkern, w, h,
678 mlib_ImageGetType(src)) != MLIB_SUCCESS) {
679 freeDataArray(env, srcRasterP->jdata, src, sdata,
680 dstRasterP->jdata, dst, ddata);
681 awt_freeParsedRaster(srcRasterP, TRUE(1));
682 awt_freeParsedRaster(dstRasterP, TRUE(1));
683 free(dkern);
684 free(kdata);
685 return 0;
686 }
687
688 if (s_printIt) {
689 fprintf(stderr, "Orig Kernel(len=%d):\n",klen)__fprintf_chk (stderr, 2 - 1, "Orig Kernel(len=%d):\n",klen);
690 for (y=kheight-1; y >= 0; y--) {
691 for (x=kwidth-1; x >= 0; x--) {
692 fprintf(stderr, "%g ", dkern[y*w+x])__fprintf_chk (stderr, 2 - 1, "%g ", dkern[y*w+x]);
693 }
694 fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
695 }
696 fprintf(stderr, "New Kernel(scale=%d):\n", scale)__fprintf_chk (stderr, 2 - 1, "New Kernel(scale=%d):\n", scale
);
697 for (y=kheight-1; y >= 0; y--) {
698 for (x=kwidth-1; x >= 0; x--) {
699 fprintf(stderr, "%d ", kdata[y*w+x])__fprintf_chk (stderr, 2 - 1, "%d ", kdata[y*w+x]);
700 }
701 fprintf(stderr, "\n")__fprintf_chk (stderr, 2 - 1, "\n");
702 }
703 }
704
705 cmask = (1<<src->channels)-1;
706 status = (*sMlibFns[MLIB_CONVMxN].fptr)(dst, src, kdata, w, h,
707 (w-1)/2, (h-1)/2, scale, cmask,
708 getMlibEdgeHint(edgeHint));
709
710 if (status != MLIB_SUCCESS) {
711 printMedialibError(status);
712 retStatus = 0;
713 }
714
715 if (s_printIt) {
716 unsigned int *dP;
717 if (s_startOff != 0) {
718 printf("Starting at %d\n", s_startOff)__printf_chk (2 - 1, "Starting at %d\n", s_startOff);
719 }
720 if (sdata == NULL((void*)0)) {
721 dP = (unsigned int *) mlib_ImageGetData(src);
722 }
723 else {
724 dP = (unsigned int *) sdata;
725 }
726 printf("src is\n")__printf_chk (2 - 1, "src is\n");
727 for (i=0; i < 20; i++) {
728 printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
729 }
730 printf("\n")__printf_chk (2 - 1, "\n");
731 if (ddata == NULL((void*)0)) {
732 dP = (unsigned int *)mlib_ImageGetData(dst);
733 }
734 else {
735 dP = (unsigned int *) ddata;
736 }
737 printf("dst is\n")__printf_chk (2 - 1, "dst is\n");
738 for (i=0; i < 20; i++) {
739 printf("%x ",dP[s_startOff+i])__printf_chk (2 - 1, "%x ",dP[s_startOff+i]);
740 }
741 printf("\n")__printf_chk (2 - 1, "\n");
742 }
743
744 /* Means that we couldn't write directly into the destination buffer */
745 if (ddata == NULL((void*)0)) {
746 if (storeRasterArray(env, srcRasterP, dstRasterP, dst) < 0) {
747 retStatus = setPixelsFormMlibImage(env, dstRasterP, dst);
748 }
749 }
750
751 /* Release the pinned memory */
752 freeDataArray(env, srcRasterP->jdata, src, sdata,
753 dstRasterP->jdata, dst, ddata);
754 awt_freeParsedRaster(srcRasterP, TRUE(1));
755 awt_freeParsedRaster(dstRasterP, TRUE(1));
756 free(dkern);
757 free(kdata);
758
759 if (s_timeIt) (*stop_timer)(3600,1);
760
761 return retStatus;
762}
763
764
765JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
766Java_sun_awt_image_ImagingLib_transformBI(JNIEnv *env, jobject this,
767 jobject jsrc,
768 jobject jdst,
769 jdoubleArray jmatrix,
770 jint interpType)
771{
772 mlib_image *src;
773 mlib_image *dst;
774 int i;
775 int j = 0;
776 int retStatus = 1;
777 mlib_status status;
778 double *matrix;
779 mlib_d64 mtx[6];
780 void *sdata;
781 void *ddata;
782 BufImageS_t *srcImageP;
783 BufImageS_t *dstImageP;
784 mlib_filter filter;
785 mlibHintS_t hint;
786 unsigned int *dP;
787 int useIndexed;
788 int nbands;
789
790 /* This function requires a lot of local refs ??? Is 64 enough ??? */
791 if ((*env)->EnsureLocalCapacity(env, 64) < 0)
792 return 0;
793
794 if (s_nomlib) return 0;
795 if (s_timeIt) {
796 (*start_timer)(3600);
797 }
798
799 switch(interpType) {
800 case java_awt_image_AffineTransformOp_TYPE_BILINEAR2L:
801 filter = MLIB_BILINEAR;
802 break;
803 case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR1L:
804 filter = MLIB_NEAREST;
805 break;
806 case java_awt_image_AffineTransformOp_TYPE_BICUBIC3L:
807 filter = MLIB_BICUBIC;
808 break;
809 default:
810 JNU_ThrowInternalError(env, "Unknown interpolation type");
811 return -1;
812 }
813
814 if ((*env)->GetArrayLength(env, jmatrix) < 6) {
815 /*
816 * Very unlikely, however we should check for this:
817 * if given matrix array is too short, we can't handle it
818 */
819 return 0;
820 }
821
822 matrix = (*env)->GetPrimitiveArrayCritical(env, jmatrix, NULL((void*)0));
823 if (matrix == NULL((void*)0)) {
824 /* out of memory error already thrown */
825 return 0;
826 }
827
828 /* Check for invalid double value in transformation matrix */
829 for (j = 0; j < 6; j++) {
830
831 if (!(IS_FINITE(matrix[j])(((matrix[j]) >= -1.7976931348623157E+308) && ((matrix
[j]) <= 1.7976931348623157E+308)))) {
832 (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);
833 return 0;
834 }
835 }
836
837 if (s_printIt) {
838 printf("matrix is %g %g %g %g %g %g\n", matrix[0], matrix[1],__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5])
839 matrix[2], matrix[3], matrix[4], matrix[5])__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
840 }
841
842 mtx[0] = matrix[0];
843 mtx[1] = matrix[2];
844 mtx[2] = matrix[4];
845 mtx[3] = matrix[1];
846 mtx[4] = matrix[3];
847 mtx[5] = matrix[5];
848
849 (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);
850
851 /* Parse the source image */
852 if (awt_parseImage(env, jsrc, &srcImageP, FALSE(0)) <= 0) {
853 /* Can't handle any custom images */
854 return 0;
855 }
856
857 /* Parse the destination image */
858 if (awt_parseImage(env, jdst, &dstImageP, FALSE(0)) <= 0) {
859 /* Can't handle any custom images */
860 awt_freeParsedImage(srcImageP, TRUE(1));
861 return 0;
862 }
863
864 /* REMIND!! Can't assume that it is the same LUT!! */
865 /* Fix 4213160, 4184283 */
866 useIndexed = (srcImageP->cmodel.cmType == INDEX_CM_TYPE3 &&
867 dstImageP->cmodel.cmType == INDEX_CM_TYPE3 &&
868 srcImageP->raster.rasterType == dstImageP->raster.rasterType &&
869 srcImageP->raster.rasterType == COMPONENT_RASTER_TYPE1);
870
871 nbands = setImageHints(env, srcImageP, dstImageP, !useIndexed, TRUE(1),
872 FALSE(0), &hint);
873 if (nbands < 1) {
874 /* Can't handle any custom images */
875 awt_freeParsedImage(srcImageP, TRUE(1));
876 awt_freeParsedImage(dstImageP, TRUE(1));
877 return 0;
878 }
879
880 /* Allocate the arrays */
881 if (allocateArray(env, srcImageP, &src, &sdata, TRUE(1),
882 hint.cvtSrcToDefault, hint.addAlpha) < 0) {
883 /* Must be some problem */
884 awt_freeParsedImage(srcImageP, TRUE(1));
885 awt_freeParsedImage(dstImageP, TRUE(1));
886 return 0;
887 }
888 if (allocateArray(env, dstImageP, &dst, &ddata, FALSE(0),
889 hint.cvtToDst, FALSE(0)) < 0) {
890 /* Must be some problem */
891 freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
892 awt_freeParsedImage(srcImageP, TRUE(1));
893 awt_freeParsedImage(dstImageP, TRUE(1));
894 return 0;
895 }
896#if 0
897fprintf(stderr,"Src----------------\n")__fprintf_chk (stderr, 2 - 1, "Src----------------\n");
898fprintf(stderr,"Type : %d\n",src->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",src->type);
899fprintf(stderr,"Channels: %d\n",src->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",src->channels
);
900fprintf(stderr,"Width : %d\n",src->width)__fprintf_chk (stderr, 2 - 1, "Width : %d\n",src->width);
901fprintf(stderr,"Height : %d\n",src->height)__fprintf_chk (stderr, 2 - 1, "Height : %d\n",src->height
);
902fprintf(stderr,"Stride : %d\n",src->stride)__fprintf_chk (stderr, 2 - 1, "Stride : %d\n",src->stride
);
903fprintf(stderr,"Flags : %d\n",src->flags)__fprintf_chk (stderr, 2 - 1, "Flags : %d\n",src->flags);
904
905fprintf(stderr,"Dst----------------\n")__fprintf_chk (stderr, 2 - 1, "Dst----------------\n");
906fprintf(stderr,"Type : %d\n",dst->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",dst->type);
907fprintf(stderr,"Channels: %d\n",dst->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",dst->channels
);
908fprintf(stderr,"Width : %d\n",dst->width)__fprintf_chk (stderr, 2 - 1, "Width : %d\n",dst->width);
909fprintf(stderr,"Height : %d\n",dst->height)__fprintf_chk (stderr, 2 - 1, "Height : %d\n",dst->height
);
910fprintf(stderr,"Stride : %d\n",dst->stride)__fprintf_chk (stderr, 2 - 1, "Stride : %d\n",dst->stride
);
911fprintf(stderr,"Flags : %d\n",dst->flags)__fprintf_chk (stderr, 2 - 1, "Flags : %d\n",dst->flags);
912#endif
913
914 if (dstImageP->cmodel.cmType == INDEX_CM_TYPE3) {
915 /* Need to clear the destination to the transparent pixel */
916 unsigned char *cP = (unsigned char *)mlib_ImageGetData(dst);
917
918 memset(cP, dstImageP->cmodel.transIdx,
919 mlib_ImageGetWidth(dst)*mlib_ImageGetHeight(dst));
920 }
921 /* Perform the transformation */
922 if ((status = (*sMlibFns[MLIB_AFFINE].fptr)(dst, src, mtx, filter,
923 MLIB_EDGE_SRC_EXTEND) != MLIB_SUCCESS))
924 {
925 printMedialibError(status);
926 freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
927 awt_freeParsedImage(srcImageP, TRUE(1));
928 awt_freeParsedImage(dstImageP, TRUE(1));
929
930 return 0;
931 }
932
933 if (s_printIt) {
934 if (sdata == NULL((void*)0)) {
935 dP = (unsigned int *) mlib_ImageGetData(src);
936 }
937 else {
938 dP = (unsigned int *) sdata;
939 }
940 printf("src is\n")__printf_chk (2 - 1, "src is\n");
941 for (i=0; i < 20; i++) {
942 printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
943 }
944 printf("\n")__printf_chk (2 - 1, "\n");
945 if (ddata == NULL((void*)0)) {
946 dP = (unsigned int *)mlib_ImageGetData(dst);
947 }
948 else {
949 dP = (unsigned int *) ddata;
950 }
951 printf("dst is\n")__printf_chk (2 - 1, "dst is\n");
952 for (i=0; i < 20; i++) {
953 printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
954 }
955 printf("\n")__printf_chk (2 - 1, "\n");
956 }
957
958 /* Means that we couldn't write directly into the destination buffer */
959 if (ddata == NULL((void*)0)) {
960 freeDataArray(env, srcImageP->raster.jdata, src, sdata,
961 NULL((void*)0), NULL((void*)0), NULL((void*)0));
962 /* Need to store it back into the array */
963 if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {
964 /* Error */
965 retStatus = 0;
966 }
967 freeDataArray(env, NULL((void*)0), NULL((void*)0), NULL((void*)0), dstImageP->raster.jdata,
968 dst, ddata);
969 }
970 else {
971 /* Release the pinned memory */
972 freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
973 }
974
975 awt_freeParsedImage(srcImageP, TRUE(1));
976 awt_freeParsedImage(dstImageP, TRUE(1));
977
978 if (s_timeIt) (*stop_timer)(3600,1);
979
980 return retStatus;
981}
982
983JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
984Java_sun_awt_image_ImagingLib_transformRaster(JNIEnv *env, jobject this,
985 jobject jsrc,
986 jobject jdst,
987 jdoubleArray jmatrix,
988 jint interpType)
989{
990 mlib_image *src;
991 mlib_image *dst;
992 int i;
993 int j = 0;
994 int retStatus = 1;
995 mlib_status status;
996 double *matrix;
997 mlib_d64 mtx[6];
998 void *sdata;
999 void *ddata;
1000 RasterS_t *srcRasterP;
1001 RasterS_t *dstRasterP;
1002 mlib_filter filter;
1003 unsigned int *dP;
1004
1005 /* This function requires a lot of local refs ??? Is 64 enough ??? */
1006 if ((*env)->EnsureLocalCapacity(env, 64) < 0)
1007 return 0;
1008
1009 if (s_nomlib) return 0;
1010 if (s_timeIt) {
1011 (*start_timer)(3600);
1012 }
1013
1014 switch(interpType) {
1015 case java_awt_image_AffineTransformOp_TYPE_BILINEAR2L:
1016 filter = MLIB_BILINEAR;
1017 break;
1018 case java_awt_image_AffineTransformOp_TYPE_NEAREST_NEIGHBOR1L:
1019 filter = MLIB_NEAREST;
1020 break;
1021 case java_awt_image_AffineTransformOp_TYPE_BICUBIC3L:
1022 filter = MLIB_BICUBIC;
1023 break;
1024 default:
1025 JNU_ThrowInternalError(env, "Unknown interpolation type");
1026 return -1;
1027 }
1028
1029 if ((srcRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
1030 JNU_ThrowOutOfMemoryError(env, "Out of memory");
1031 return -1;
1032 }
1033
1034 if ((dstRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
1035 JNU_ThrowOutOfMemoryError(env, "Out of memory");
1036 free(srcRasterP);
1037 return -1;
1038 }
1039
1040 if ((*env)->GetArrayLength(env, jmatrix) < 6) {
1041 /*
1042 * Very unlikely, however we should check for this:
1043 * if given matrix array is too short, we can't handle it.
1044 */
1045 free(srcRasterP);
1046 free(dstRasterP);
1047 return 0;
1048 }
1049
1050 matrix = (*env)->GetPrimitiveArrayCritical(env, jmatrix, NULL((void*)0));
1051 if (matrix == NULL((void*)0)) {
1052 /* out of memory error already thrown */
1053 free(srcRasterP);
1054 free(dstRasterP);
1055 return 0;
1056 }
1057
1058 /* Check for invalid double value in transformation matrix */
1059 for (j = 0; j < 6; j++) {
1060
1061 if (!(IS_FINITE(matrix[j])(((matrix[j]) >= -1.7976931348623157E+308) && ((matrix
[j]) <= 1.7976931348623157E+308)))) {
1062 (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);
1063 free(srcRasterP);
1064 free(dstRasterP);
1065
1066 return 0;
1067 }
1068 }
1069
1070 if (s_printIt) {
1071 printf("matrix is %g %g %g %g %g %g\n", matrix[0], matrix[1],__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5])
1072 matrix[2], matrix[3], matrix[4], matrix[5])__printf_chk (2 - 1, "matrix is %g %g %g %g %g %g\n", matrix[
0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
1073 }
1074
1075 mtx[0] = matrix[0];
1076 mtx[1] = matrix[2];
1077 mtx[2] = matrix[4];
1078 mtx[3] = matrix[1];
1079 mtx[4] = matrix[3];
1080 mtx[5] = matrix[5];
1081
1082 (*env)->ReleasePrimitiveArrayCritical(env, jmatrix, matrix, JNI_ABORT2);
1083
1084 /* Parse the source raster */
1085 if (awt_parseRaster(env, jsrc, srcRasterP) <= 0) {
1086 /* Can't handle any custom rasters */
1087 free(srcRasterP);
1088 free(dstRasterP);
1089 return 0;
1090 }
1091
1092 /* Parse the destination raster */
1093 if (awt_parseRaster(env, jdst, dstRasterP) <= 0) {
1094 /* Can't handle any custom images */
1095 awt_freeParsedRaster(srcRasterP, TRUE(1));
1096 free(dstRasterP);
1097 return 0;
1098 }
1099
1100 /* Allocate the arrays */
1101 if (allocateRasterArray(env, srcRasterP, &src, &sdata, TRUE(1)) < 0) {
1102 /* Must be some problem */
1103 awt_freeParsedRaster(srcRasterP, TRUE(1));
1104 awt_freeParsedRaster(dstRasterP, TRUE(1));
1105 return 0;
1106 }
1107 if (allocateRasterArray(env, dstRasterP, &dst, &ddata, FALSE(0)) < 0) {
1108 /* Must be some problem */
1109 freeDataArray(env, srcRasterP->jdata, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1110 awt_freeParsedRaster(srcRasterP, TRUE(1));
1111 awt_freeParsedRaster(dstRasterP, TRUE(1));
1112 return 0;
1113 }
1114
1115#if 0
1116fprintf(stderr,"Src----------------\n")__fprintf_chk (stderr, 2 - 1, "Src----------------\n");
1117fprintf(stderr,"Type : %d\n",src->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",src->type);
1118fprintf(stderr,"Channels: %d\n",src->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",src->channels
);
1119fprintf(stderr,"Width : %d\n",src->width)__fprintf_chk (stderr, 2 - 1, "Width : %d\n",src->width);
1120fprintf(stderr,"Height : %d\n",src->height)__fprintf_chk (stderr, 2 - 1, "Height : %d\n",src->height
);
1121fprintf(stderr,"Stride : %d\n",src->stride)__fprintf_chk (stderr, 2 - 1, "Stride : %d\n",src->stride
);
1122fprintf(stderr,"Flags : %d\n",src->flags)__fprintf_chk (stderr, 2 - 1, "Flags : %d\n",src->flags);
1123
1124fprintf(stderr,"Dst----------------\n")__fprintf_chk (stderr, 2 - 1, "Dst----------------\n");
1125fprintf(stderr,"Type : %d\n",dst->type)__fprintf_chk (stderr, 2 - 1, "Type : %d\n",dst->type);
1126fprintf(stderr,"Channels: %d\n",dst->channels)__fprintf_chk (stderr, 2 - 1, "Channels: %d\n",dst->channels
);
1127fprintf(stderr,"Width : %d\n",dst->width)__fprintf_chk (stderr, 2 - 1, "Width : %d\n",dst->width);
1128fprintf(stderr,"Height : %d\n",dst->height)__fprintf_chk (stderr, 2 - 1, "Height : %d\n",dst->height
);
1129fprintf(stderr,"Stride : %d\n",dst->stride)__fprintf_chk (stderr, 2 - 1, "Stride : %d\n",dst->stride
);
1130fprintf(stderr,"Flags : %d\n",dst->flags)__fprintf_chk (stderr, 2 - 1, "Flags : %d\n",dst->flags);
1131#endif
1132
1133 {
1134 unsigned char *cP = (unsigned char *)mlib_ImageGetData(dst);
1135
1136 memset(cP, 0, mlib_ImageGetWidth(dst)*mlib_ImageGetHeight(dst));
1137 }
1138
1139 /* Perform the transformation */
1140 if ((status = (*sMlibFns[MLIB_AFFINE].fptr)(dst, src, mtx, filter,
1141 MLIB_EDGE_SRC_EXTEND) != MLIB_SUCCESS))
1142 {
1143 printMedialibError(status);
1144 /* REMIND: Free the regions */
1145 return 0;
1146 }
1147
1148 if (s_printIt) {
1149 if (sdata == NULL((void*)0)) {
1150 dP = (unsigned int *) mlib_ImageGetData(src);
1151 }
1152 else {
1153 dP = (unsigned int *) sdata;
1154 }
1155 printf("src is\n")__printf_chk (2 - 1, "src is\n");
1156 for (i=0; i < 20; i++) {
1157 printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
1158 }
1159 printf("\n")__printf_chk (2 - 1, "\n");
1160 if (ddata == NULL((void*)0)) {
1161 dP = (unsigned int *)mlib_ImageGetData(dst);
1162 }
1163 else {
1164 dP = (unsigned int *) ddata;
1165 }
1166 printf("dst is\n")__printf_chk (2 - 1, "dst is\n");
1167 for (i=0; i < 20; i++) {
1168 printf("%x ",dP[i])__printf_chk (2 - 1, "%x ",dP[i]);
1169 }
1170 printf("\n")__printf_chk (2 - 1, "\n");
1171 }
1172
1173 /* Means that we couldn't write directly into the destination buffer */
1174 if (ddata == NULL((void*)0)) {
1175 /* Need to store it back into the array */
1176 if (storeRasterArray(env, srcRasterP, dstRasterP, dst) < 0) {
1177 (*env)->ExceptionClear(env); // Could not store the array, try another way
1178 retStatus = setPixelsFormMlibImage(env, dstRasterP, dst);
1179 }
1180 }
1181
1182 /* Release the pinned memory */
1183 freeDataArray(env, srcRasterP->jdata, src, sdata,
1184 dstRasterP->jdata, dst, ddata);
1185
1186 awt_freeParsedRaster(srcRasterP, TRUE(1));
1187 awt_freeParsedRaster(dstRasterP, TRUE(1));
1188
1189 if (s_timeIt) (*stop_timer)(3600,1);
1190
1191 return retStatus;
1192}
1193
1194typedef struct {
1195 jobject jArray;
1196 jsize length;
1197 unsigned char *table;
1198} LookupArrayInfo;
1199
1200#define NLUT8 8
1201
1202#ifdef _LITTLE_ENDIAN1
1203#define INDEXES{ 3, 2, 1, 0, 7, 6, 5, 4 } { 3, 2, 1, 0, 7, 6, 5, 4 }
1204#else
1205#define INDEXES{ 3, 2, 1, 0, 7, 6, 5, 4 } { 0, 1, 2, 3, 4, 5, 6, 7 }
1206#endif
1207
1208static int lookupShortData(mlib_image* src, mlib_image* dst,
1209 LookupArrayInfo* lookup)
1210{
1211 int x, y;
1212 unsigned int mask = NLUT8-1;
1213
1214 unsigned short* srcLine = (unsigned short*)src->data;
1215 unsigned char* dstLine = (unsigned char*)dst->data;
1216
1217 static int indexes[NLUT8] = INDEXES{ 3, 2, 1, 0, 7, 6, 5, 4 };
1218
1219 if (src->width != dst->width || src->height != dst->height) {
1220 return 0;
1221 }
1222
1223 for (y=0; y < src->height; y++) {
1224 int nloop, nx;
1225 int npix = src->width;
1226
1227 unsigned short* srcPixel = srcLine;
1228 unsigned char* dstPixel = dstLine;
1229
1230#ifdef SIMPLE_LOOKUP_LOOP
1231 for (x=0; status && x < width; x++) {
1232 unsigned short s = *srcPixel++;
1233 if (s >= lookup->length) {
1234 /* we can not handle source image using
1235 * byte lookup table. Fall back to processing
1236 * images in java
1237 */
1238 return 0;
1239 }
1240 *dstPixel++ = lookup->table[s];
1241 }
1242#else
1243 /* Get to 32 bit-aligned point */
1244 while(((uintptr_t)dstPixel & 0x3) != 0 && npix>0) {
1245 unsigned short s = *srcPixel++;
1246 if (s >= lookup->length) {
1247 return 0;
1248 }
1249 *dstPixel++ = lookup->table[s];
1250 npix--;
1251 }
1252
1253 /*
1254 * Do NLUT pixels per loop iteration.
1255 * Pack into ints and write out 2 at a time.
1256 */
1257 nloop = npix/NLUT8;
1258 nx = npix%NLUT8;
1259
1260 for(x=nloop; x!=0; x--) {
1261 int i = 0;
1262 int* dstP = (int*)dstPixel;
1263
1264 for (i = 0; i < NLUT8; i++) {
1265 if (srcPixel[i] >= lookup->length) {
1266 return 0;
1267 }
1268 }
1269
1270 dstP[0] = (int)
1271 ((lookup->table[srcPixel[indexes[0]]] << 24) |
1272 (lookup->table[srcPixel[indexes[1]]] << 16) |
1273 (lookup->table[srcPixel[indexes[2]]] << 8) |
1274 lookup->table[srcPixel[indexes[3]]]);
1275 dstP[1] = (int)
1276 ((lookup->table[srcPixel[indexes[4]]] << 24) |
1277 (lookup->table[srcPixel[indexes[5]]] << 16) |
1278 (lookup->table[srcPixel[indexes[6]]] << 8) |
1279 lookup->table[srcPixel[indexes[7]]]);
1280
1281
1282 dstPixel += NLUT8;
1283 srcPixel += NLUT8;
1284 }
1285
1286 /*
1287 * Complete any remaining pixels
1288 */
1289 for(x=nx; x!=0; x--) {
1290 unsigned short s = *srcPixel++;
1291 if (s >= lookup->length) {
1292 return 0;
1293 }
1294 *dstPixel++ = lookup->table[s];
1295 }
1296#endif
1297
1298 dstLine += dst->stride; // array of bytes, scan stride in bytes
1299 srcLine += src->stride / 2; // array of shorts, scan stride in bytes
1300 }
1301 return 1;
1302}
1303
1304JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
1305Java_sun_awt_image_ImagingLib_lookupByteBI(JNIEnv *env, jobject thisLib,
1306 jobject jsrc, jobject jdst,
1307 jobjectArray jtableArrays)
1308{
1309 mlib_image *src;
1310 mlib_image *dst;
1311 void *sdata, *ddata;
1312 unsigned char **tbl;
1313 unsigned char lut[256];
1314 int retStatus = 1;
1315 int i;
1316 mlib_status status;
1317 int lut_nbands;
1318 LookupArrayInfo *jtable;
1319 BufImageS_t *srcImageP, *dstImageP;
1320 int nbands;
1321 int ncomponents;
1322 mlibHintS_t hint;
1323
1324 /* This function requires a lot of local refs ??? Is 64 enough ??? */
1325 if ((*env)->EnsureLocalCapacity(env, 64) < 0)
1326 return 0;
1327
1328 if (s_nomlib) return 0;
1329 if (s_timeIt) (*start_timer)(3600);
1330
1331 /* Parse the source image */
1332 if (awt_parseImage(env, jsrc, &srcImageP, FALSE(0)) <= 0) {
1333 /* Can't handle any custom images */
1334 return 0;
1335 }
1336
1337 /* Parse the destination image */
1338 if (awt_parseImage(env, jdst, &dstImageP, FALSE(0)) <= 0) {
1339 /* Can't handle any custom images */
1340 awt_freeParsedImage(srcImageP, TRUE(1));
1341 return 0;
1342 }
1343
1344 nbands = setImageHints(env, srcImageP, dstImageP, FALSE(0), TRUE(1),
1345 FALSE(0), &hint);
1346
1347 if (nbands < 1 || nbands > srcImageP->cmodel.numComponents) {
1348 /* Can't handle any custom images */
1349 awt_freeParsedImage(srcImageP, TRUE(1));
1350 awt_freeParsedImage(dstImageP, TRUE(1));
1351 return 0;
1352 }
1353
1354 ncomponents = srcImageP->cmodel.isDefaultCompatCM
1355 ? 4
1356 : srcImageP->cmodel.numComponents;
1357
1358 /* Make sure that color order can be used for
1359 * re-ordering of lookup arrays.
1360 */
1361 for (i = 0; i < nbands; i++) {
1362 int idx = srcImageP->hints.colorOrder[i];
1363
1364 if (idx < 0 || idx >= ncomponents) {
1365 awt_freeParsedImage(srcImageP, TRUE(1));
1366 awt_freeParsedImage(dstImageP, TRUE(1));
1367 return 0;
1368 }
1369 }
1370
1371 lut_nbands = (*env)->GetArrayLength(env, jtableArrays);
1372
1373 if (lut_nbands > ncomponents) {
1374 lut_nbands = ncomponents;
1375 }
1376
1377 tbl = NULL((void*)0);
1378 if (SAFE_TO_ALLOC_2(ncomponents, sizeof(unsigned char *))(((ncomponents) > 0) && ((sizeof(unsigned char *))
> 0) && ((0x7fffffff / (ncomponents)) > (sizeof
(unsigned char *))))) {
1379 tbl = (unsigned char **)
1380 calloc(1, ncomponents * sizeof(unsigned char *));
1381 }
1382
1383 jtable = NULL((void*)0);
1384 if (SAFE_TO_ALLOC_2(lut_nbands, sizeof(LookupArrayInfo))(((lut_nbands) > 0) && ((sizeof(LookupArrayInfo)) >
0) && ((0x7fffffff / (lut_nbands)) > (sizeof(LookupArrayInfo
))))) {
1385 jtable = (LookupArrayInfo *)malloc(lut_nbands * sizeof (LookupArrayInfo));
1386 }
1387
1388 if (tbl == NULL((void*)0) || jtable == NULL((void*)0)) {
1389 if (tbl != NULL((void*)0)) free(tbl);
1390 if (jtable != NULL((void*)0)) free(jtable);
1391 awt_freeParsedImage(srcImageP, TRUE(1));
1392 awt_freeParsedImage(dstImageP, TRUE(1));
1393 JNU_ThrowNullPointerException(env, "NULL LUT");
1394 return 0;
1395 }
1396 /* Need to grab these pointers before we lock down arrays */
1397 for (i=0; i < lut_nbands; i++) {
1398 jtable[i].jArray = (*env)->GetObjectArrayElement(env, jtableArrays, i);
1399
1400 if (jtable[i].jArray != NULL((void*)0)) {
1401 jtable[i].length = (*env)->GetArrayLength(env, jtable[i].jArray);
1402 jtable[i].table = NULL((void*)0);
1403
1404 if (jtable[i].length < 256) {
1405 /* we may read outside the table during lookup */
1406 jtable[i].jArray = NULL((void*)0);
1407 jtable[i].length = 0;
1408 }
1409 }
1410 if (jtable[i].jArray == NULL((void*)0)) {
1411 free(tbl);
1412 free(jtable);
1413 awt_freeParsedImage(srcImageP, TRUE(1));
1414 awt_freeParsedImage(dstImageP, TRUE(1));
1415 return 0;
1416 }
1417 }
1418
1419 /* Allocate the arrays */
1420 if (allocateArray(env, srcImageP, &src, &sdata, TRUE(1), FALSE(0), FALSE(0)) < 0) {
1421 /* Must be some problem */
1422 free(tbl);
1423 free(jtable);
1424 awt_freeParsedImage(srcImageP, TRUE(1));
1425 awt_freeParsedImage(dstImageP, TRUE(1));
1426 return 0;
1427 }
1428 if (allocateArray(env, dstImageP, &dst, &ddata, FALSE(0), FALSE(0), FALSE(0)) < 0) {
1429 /* Must be some problem */
1430 free(tbl);
1431 free(jtable);
1432 freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1433 awt_freeParsedImage(srcImageP, TRUE(1));
1434 awt_freeParsedImage(dstImageP, TRUE(1));
1435 return 0;
1436 }
1437
1438 /* Set up a straight lut so we don't mess around with alpha */
1439 /*
1440 * NB: medialib lookup routine expects lookup array for each
1441 * component of source image including alpha.
1442 * If lookup table we got form the java layer does not contain
1443 * sufficient number of lookup arrays we add references to identity
1444 * lookup array to make medialib happier.
1445 */
1446 if (lut_nbands < ncomponents) {
1447 int j;
1448 /* REMIND: This should be the size of the input lut!! */
1449 for (j=0; j < 256; j++) {
1450 lut[j] = j;
1451 }
1452 for (j=0; j < ncomponents; j++) {
1453 tbl[j] = lut;
1454 }
1455 }
1456
1457 for (i=0; i < lut_nbands; i++) {
1458 jtable[i].table = (unsigned char *)
1459 (*env)->GetPrimitiveArrayCritical(env, jtable[i].jArray, NULL((void*)0));
1460 if (jtable[i].table == NULL((void*)0)) {
1461 /* Free what we've got so far. */
1462 int j;
1463 for (j = 0; j < i; j++) {
1464 (*env)->ReleasePrimitiveArrayCritical(env,
1465 jtable[j].jArray,
1466 (jbyte *) jtable[j].table,
1467 JNI_ABORT2);
1468 }
1469 free(tbl);
1470 free(jtable);
1471 freeArray(env, srcImageP, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1472 awt_freeParsedImage(srcImageP, TRUE(1));
1473 awt_freeParsedImage(dstImageP, TRUE(1));
1474 return 0;
1475 }
1476 tbl[srcImageP->hints.colorOrder[i]] = jtable[i].table;
1477 }
1478
1479 if (lut_nbands == 1) {
1480 for (i=1; i < nbands -
1481 srcImageP->cmodel.supportsAlpha; i++) {
1482 tbl[srcImageP->hints.colorOrder[i]] = jtable[0].table;
1483 }
1484 }
1485
1486 /* Mlib needs 16bit lookuptable and must be signed! */
1487 if (src->type == MLIB_SHORT) {
1488 if (dst->type == MLIB_BYTE) {
1489 if (nbands > 1) {
1490 retStatus = 0;
1491 }
1492 else {
1493 retStatus = lookupShortData(src, dst, &jtable[0]);
1494 }
1495 }
1496 /* How about ddata == null? */
1497 }
1498 else if ((status = (*sMlibFns[MLIB_LOOKUP].fptr)(dst, src,
1499 (void **)tbl) != MLIB_SUCCESS)) {
1500 printMedialibError(status);
1501 retStatus = 0;
1502 }
1503
1504 /* Release the LUT */
1505 for (i=0; i < lut_nbands; i++) {
1506 (*env)->ReleasePrimitiveArrayCritical(env, jtable[i].jArray,
1507 (jbyte *) jtable[i].table, JNI_ABORT2);
1508 }
1509 free ((void *) jtable);
1510 free ((void *) tbl);
1511
1512 /*
1513 * Means that we couldn't write directly into
1514 * the destination buffer
1515 */
1516 if (ddata == NULL((void*)0)) {
1517
1518 /* Need to store it back into the array */
1519 if (storeImageArray(env, srcImageP, dstImageP, dst) < 0) {
1520 /* Error */
1521 retStatus = 0;
1522 }
1523 }
1524
1525
1526 /* Release the pinned memory */
1527 freeArray(env, srcImageP, src, sdata, dstImageP, dst, ddata);
1528
1529 awt_freeParsedImage(srcImageP, TRUE(1));
1530 awt_freeParsedImage(dstImageP, TRUE(1));
1531
1532 if (s_timeIt) (*stop_timer)(3600, 1);
1533
1534 return retStatus;
1535}
1536
1537JNIEXPORT__attribute__((visibility("default"))) jint JNICALL
1538Java_sun_awt_image_ImagingLib_lookupByteRaster(JNIEnv *env,
1539 jobject this,
1540 jobject jsrc,
1541 jobject jdst,
1542 jobjectArray jtableArrays)
1543{
1544 RasterS_t* srcRasterP;
1545 RasterS_t* dstRasterP;
1546 mlib_image* src;
1547 mlib_image* dst;
1548 void* sdata;
1549 void* ddata;
1550 LookupArrayInfo jtable[4];
1551 unsigned char* mlib_lookupTable[4];
1552 int i;
1553 int retStatus = 1;
1554 mlib_status status;
1555 int jlen;
1556 int lut_nbands;
1557 int src_nbands;
1558 int dst_nbands;
1559 unsigned char ilut[256];
1560
1561 /* This function requires a lot of local refs ??? Is 64 enough ??? */
1562 if ((*env)->EnsureLocalCapacity(env, 64) < 0)
1563 return 0;
1564
1565 if (s_nomlib) return 0;
1566 if (s_timeIt) (*start_timer)(3600);
1567
1568 if ((srcRasterP = (RasterS_t*) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
1569 JNU_ThrowOutOfMemoryError(env, "Out of memory");
1570 return -1;
1571 }
1572
1573 if ((dstRasterP = (RasterS_t *) calloc(1, sizeof(RasterS_t))) == NULL((void*)0)) {
1574 JNU_ThrowOutOfMemoryError(env, "Out of memory");
1575 free(srcRasterP);
1576 return -1;
1577 }
1578
1579 /* Parse the source raster - reject custom images */
1580 if (awt_parseRaster(env, jsrc, srcRasterP) <= 0) {
1581 free(srcRasterP);
1582 free(dstRasterP);
1583 return 0;
1584 }
1585
1586 /* Parse the destination image - reject custom images */
1587 if (awt_parseRaster(env, jdst, dstRasterP) <= 0) {
1588 awt_freeParsedRaster(srcRasterP, TRUE(1));
1589 free(dstRasterP);
1590 return 0;
1591 }
1592
1593 jlen = (*env)->GetArrayLength(env, jtableArrays);
1594
1595 lut_nbands = jlen;
1596 src_nbands = srcRasterP->numBands;
1597 dst_nbands = dstRasterP->numBands;
1598
1599 /* adjust number of lookup bands */
1600 if (lut_nbands > src_nbands) {
1601 lut_nbands = src_nbands;
1602 }
1603
1604 /* MediaLib can't do more than 4 bands */
1605 if (src_nbands <= 0 || src_nbands > 4 ||
1606 dst_nbands <= 0 || dst_nbands > 4 ||
1607 lut_nbands <= 0 || lut_nbands > 4 ||
1608 src_nbands != dst_nbands ||
1609 ((lut_nbands != 1) && (lut_nbands != src_nbands)))
1610 {
1611 // we should free parsed rasters here
1612 awt_freeParsedRaster(srcRasterP, TRUE(1));
1613 awt_freeParsedRaster(dstRasterP, TRUE(1));
1614 return 0;
1615 }
1616
1617 /* Allocate the raster arrays */
1618 if (allocateRasterArray(env, srcRasterP, &src, &sdata, TRUE(1)) < 0) {
1619 /* Must be some problem */
1620 awt_freeParsedRaster(srcRasterP, TRUE(1));
1621 awt_freeParsedRaster(dstRasterP, TRUE(1));
1622 return 0;
1623 }
1624 if (allocateRasterArray(env, dstRasterP, &dst, &ddata, FALSE(0)) < 0) {
1625 /* Must be some problem */
1626 freeDataArray(env, srcRasterP->jdata, src, sdata, NULL((void*)0), NULL((void*)0), NULL((void*)0));
1627 awt_freeParsedRaster(srcRasterP, TRUE(1));
1628 awt_freeParsedRaster(dstRasterP, TRUE(1));
1629 return 0;
1630 }
1631
1632 /*
1633 * Well, until now we have analyzed number of bands in
1634 * src and dst rasters.
1635 * However, it is not enough because medialib lookup routine uses
1636 * number of channels of medialib image. Note that in certain
1637 * case number of channels may differs form the number of bands.
1638 * Good example is raster that is used in TYPE_INT_RGB buffered
1639 * image: it has 3 bands, but their medialib representation has
1640 * 4 channels.
1641 *
1642 * In order to avoid the lookup routine failure, we need:
1643 *
1644 * 1. verify that src and dst have same number of channels.
1645 * 2. provide lookup array for every channel. If we have "extra"
1646 * channel (like the raster described above) then we need to
1647 * provide identical lookup array.
1648 */
1649 if (src->channels != dst->channels) {
1650 freeDataArray(env, srcRasterP->jdata, src, sdata,
1651 dstRasterP->jdata, dst, ddata);
1652
1653 awt_freeParsedRaster(srcRasterP, TRUE(1));
1654 awt_freeParsedRaster(dstRasterP, TRUE(1));
1655 return 0;
1656 }
1657
1658 if (src_nbands < src->channels) {
1659 for (i = 0; i < 256; i++) {
1660 ilut[i] = i;
1661 }
1662 }
1663
1664
1665 /* Get references to the lookup table arrays */
1666 /* Need to grab these pointers before we lock down arrays */
1667 for (i=0; i < lut_nbands; i++) {
1668 jtable[i].jArray = (*env)->GetObjectArrayElement(env, jtableArrays, i);
1669 jtable[i].table = NULL((void*)0);
1670 if (jtable[i].jArray != NULL((void*)0)) {
1671 jtable[i].length = (*env)->GetArrayLength(env, jtable[i].jArray);
1672 if (jtable[i].length < 256) {
1673 /* we may read outside the table during lookup */
1674 jtable[i].jArray = NULL((void*)0);
1675 }
1676 }
1677
1678 if (jtable[i].jArray == NULL((void*)0))
1679 {
1680 freeDataArray(env, srcRasterP->jdata, src, sdata,
1681 dstRasterP->jdata, dst, ddata);
1682
1683 awt_freeParsedRaster(srcRasterP, TRUE(1));
1684 awt_freeParsedRaster(dstRasterP, TRUE(1));
1685 return 0;
1686 }
1687 }
1688
1689 for (i=0; i < lut_nbands; i++) {
1690 jtable[i].table = (unsigned char *)
1691 (*env)->GetPrimitiveArrayCritical(env, jtable[i].jArray, NULL((void*)0));
1692 if (jtable[i].table == NULL((void*)0)) {
1693 /* Free what we've got so far. */
1694 int j;
1695 for (j = 0; j < i; j++) {
1696 (*env)->ReleasePrimitiveArrayCritical(env,
1697 jtable[j].jArray,
1698 (jbyte *) jtable[j].table,
1699 JNI_ABORT2);
1700 }
1701 freeDataArray(env, srcRasterP->jdata, src, sdata,
1702 dstRasterP->jdata, dst, ddata);
1703 awt_freeParsedRaster(srcRasterP, TRUE(1));
1704 awt_freeParsedRaster(dstRasterP, TRUE(1));
1705 return 0;
1706 }
1707 mlib_lookupTable[i] = jtable[i].table;
1708 }
1709
1710 /*
1711 * Medialib routine expects lookup array for each band of raster.
1712 * Setup the rest of lookup arrays if supplied lookup table
1713 * contains single lookup array.
1714 */
1715 for (i = lut_nbands; i < src_nbands; i++) {
1716 mlib_lookupTable[i] = jtable[0].table;
1717 }
1718
1719 /*
1720 * Setup lookup array for "extra" channels
1721 */
1722 for ( ; i < src->channels; i++) {
1723 mlib_lookupTable[i] = ilut;
1724 }
1725
1726 /* Mlib needs 16bit lookuptable and must be signed! */
1727 if (src->type == MLIB_SHORT) {
1728 if (dst->type == MLIB_BYTE) {
1729 if (lut_nbands > 1) {
1730 retStatus = 0;
1731 } else {
1732 retStatus = lookupShortData(src, dst, &jtable[0]);
1733 }
1734 }
1735 /* How about ddata == null? */
1736 } else if ((status = (*sMlibFns[MLIB_LOOKUP].fptr)(dst, src,
1737 (void **)mlib_lookupTable) != MLIB_SUCCESS)) {
1738 printMedialibError(status);
1739 retStatus = 0;
1740 }
1741
1742 /* Release the LUT */
1743 for (i=0; i < lut_nbands; i++) {
1744 (*env)->ReleasePrimitiveArrayCritical(env, jtable[i].jArray,
1745 (jbyte *) jtable[i].table, JNI_ABORT2);
1746 }
1747
1748 /*
1749 * Means that we couldn't write directly into
1750 * the destination buffer
1751 */
1752 if (ddata == NULL((void*)0)) {
1753 if (storeRasterArray(env, srcRasterP, dstRasterP, dst) < 0) {
1754 retStatus = setPixelsFormMlibImage(env, dstRasterP, dst);
1755 }
1756 }
1757
1758 /* Release the pinned memory */
1759 freeDataArray(env, srcRasterP->jdata, src, sdata,
1760 dstRasterP->jdata, dst, ddata);
1761
1762 awt_freeParsedRaster(srcRasterP, TRUE(1));
1763 awt_freeParsedRaster(dstRasterP, TRUE(1));
1764
1765 if (s_timeIt) (*stop_timer)(3600, 1);
1766
1767 return retStatus;
1768}
1769
1770
1771JNIEXPORT__attribute__((visibility("default"))) jboolean JNICALL
1772Java_sun_awt_image_ImagingLib_init(JNIEnv *env, jclass thisClass) {
1773 char *start;
1774 if (getenv("IMLIB_DEBUG")) {
1775 start_timer = awt_setMlibStartTimer();
1776 stop_timer = awt_setMlibStopTimer();
1777 if (start_timer && stop_timer) {
1778 s_timeIt = 1;
1779 }
1780 }
1781
1782 if (getenv("IMLIB_PRINT")) {
1783 s_printIt = 1;
1784 }
1785 if ((start = getenv("IMLIB_START")) != NULL((void*)0)) {
1786 sscanf(start, "%d", &s_startOff);
1787 }
1788
1789 if (getenv ("IMLIB_NOMLIB")) {
1790 s_nomlib = 1;
1791 return JNI_FALSE0;
1792 }
1793
1794 /* This function is platform-dependent and is in awt_mlib.c */
1795 if (awt_getImagingLib(env, (mlibFnS_t *)&sMlibFns, &sMlibSysFns) !=
1796 MLIB_SUCCESS)
1797 {
1798 s_nomlib = 1;
1799 return JNI_FALSE0;
1800 }
1801 return JNI_TRUE1;
1802}
1803
1804/* REMIND: How to specify border? */
1805static void extendEdge(JNIEnv *env, BufImageS_t *imageP,
1806 int *widthP, int *heightP) {
1807 RasterS_t *rasterP = &imageP->raster;
1808 int width;
1809 int height;
1810 /* Useful for convolution? */
1811
1812 jobject jbaseraster = (*env)->GetObjectField(env, rasterP->jraster,
1813 g_RasterBaseRasterID);
1814 width = rasterP->width;
1815 height = rasterP->height;
1816#ifdef WORKING
1817 if (! JNU_IsNull(env, jbaseraster)((jbaseraster) == ((void*)0)) &&
1818 !(*env)->IsSameObject(env, rasterP->jraster, jbaseraster)) {
1819 int xOff;
1820 int yOff;
1821 int baseWidth;
1822 int baseHeight;
1823 int baseXoff;
1824 int baseYoff;
1825 /* Not the same object so get the width and height */
1826 xOff = (*env)->GetIntField(env, rasterP->jraster, g_RasterXOffsetID);
1827 yOff = (*env)->GetIntField(env, rasterP->jraster, g_RasterYOffsetID);
1828 baseWidth = (*env)->GetIntField(env, jbaseraster, g_RasterWidthID);
1829 baseHeight = (*env)->GetIntField(env, jbaseraster, g_RasterHeightID);
1830 baseXoff = (*env)->GetIntField(env, jbaseraster, g_RasterXOffsetID);
1831 baseYoff = (*env)->GetIntField(env, jbaseraster, g_RasterYOffsetID);
1832
1833 if (xOff + rasterP->width < baseXoff + baseWidth) {
1834 /* Can use edge */
1835 width++;
1836 }
1837 if (yOff + rasterP->height < baseYoff + baseHeight) {
1838 /* Can use edge */
1839 height++;
1840 }
1841
1842 }
1843#endif
1844
1845}
1846
1847static int
1848setImageHints(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
1849 int expandICM, int useAlpha,
1850 int premultiply, mlibHintS_t *hintP)
1851{
1852 ColorModelS_t *srcCMP = &srcP->cmodel;
1853 ColorModelS_t *dstCMP = &dstP->cmodel;
1854 int nbands = 0;
1855 int ncomponents;
1856
1857 hintP->dataType = srcP->raster.dataType;
1858 hintP->addAlpha = FALSE(0);
1859
1860 /* Are the color spaces the same? */
1861 if (srcCMP->csType != dstCMP->csType) {
1862 /* If the src is GRAY and dst RGB, we can handle it */
1863 if (!(srcCMP->csType == java_awt_color_ColorSpace_TYPE_GRAY6L &&
1864 dstCMP->csType == java_awt_color_ColorSpace_TYPE_RGB5L)) {
1865 /* Nope, need to handle that in java for now */
1866 return -1;
1867 }
1868 else {
1869 hintP->cvtSrcToDefault = TRUE(1);
1870 }
1871 }
1872 else {
1873 if (srcP->hints.needToExpand) {
1874 hintP->cvtSrcToDefault = TRUE(1);
1875 }
1876 else {
1877 /* Need to initialize this */
1878 hintP->cvtSrcToDefault = FALSE(0);
1879 }
1880 }
1881
1882 ncomponents = srcCMP->numComponents;
1883 if ((useAlpha == 0) && srcCMP->supportsAlpha) {
1884 ncomponents--; /* ?? */
1885 /* Not really, more like shrink src to get rid of alpha */
1886 hintP->cvtSrcToDefault = TRUE(1);
1887 }
1888
1889 hintP->dataType = srcP->raster.dataType;
1890 if (hintP->cvtSrcToDefault == FALSE(0)) {
1891 if (srcCMP->cmType == INDEX_CM_TYPE3) {
1892 if (expandICM) {
1893 nbands = srcCMP->numComponents;
1894 hintP->cvtSrcToDefault = TRUE(1);
1895
1896 if (dstCMP->isDefaultCompatCM) {
1897 hintP->allocDefaultDst = FALSE(0);
1898 hintP->cvtToDst = FALSE(0);
1899 }
1900 else if (dstCMP->isDefaultCompatCM) {
1901 hintP->allocDefaultDst = FALSE(0);
1902 hintP->cvtToDst = FALSE(0);
1903 }
1904 }
1905 else {
1906 nbands = 1;
1907 hintP->cvtSrcToDefault = FALSE(0);
1908 }
1909
1910 }
1911 else {
1912 if (srcP->hints.packing & INTERLEAVED0x10) {
1913 nbands = srcCMP->numComponents;
1914 }
1915 else {
1916 nbands = 1;
1917 }
1918
1919 /* Look at the packing */
1920 if ((srcP->hints.packing&BYTE_INTERLEAVED(0x1 | 0x10))==BYTE_INTERLEAVED(0x1 | 0x10) ||
1921 (srcP->hints.packing&SHORT_INTERLEAVED(0x2 | 0x10))==SHORT_INTERLEAVED(0x2 | 0x10)||
1922 (srcP->hints.packing&BYTE_SINGLE_BAND(0x1 | 0x30)) == BYTE_SINGLE_BAND(0x1 | 0x30)||
1923 (srcP->hints.packing&SHORT_SINGLE_BAND(0x2 | 0x30))==SHORT_SINGLE_BAND(0x2 | 0x30)||
1924 (srcP->hints.packing&BYTE_BANDED(0x1 | 0x20)) == BYTE_BANDED(0x1 | 0x20) ||
1925 (srcP->hints.packing&SHORT_BANDED(0x2 | 0x20)) == SHORT_BANDED(0x2 | 0x20)) {
1926 /* Can use src directly */
1927 hintP->cvtSrcToDefault = FALSE(0);
1928 }
1929 else {
1930 /* Must be packed or custom */
1931 hintP->cvtSrcToDefault = TRUE(1);
1932 }
1933 }
1934 }
1935 if (hintP->cvtSrcToDefault) {
1936 /* By definition */
1937 nbands = 4; /* What about alpha? */
1938 hintP->dataType = BYTE_DATA_TYPE1;
1939 hintP->needToCopy = TRUE(1);
1940
1941 if (srcP->imageType == dstP->imageType) {
1942 hintP->cvtToDst = TRUE(1);
1943 }
1944 else if (dstP->cmodel.isDefaultCM) {
1945 /* Not necessarily */
1946 hintP->cvtToDst = FALSE(0);
1947 }
1948 else {
1949 hintP->cvtToDst = TRUE(1);
1950 }
1951 }
1952 else {
1953 int srcImageType = srcP->imageType;
1954 int dstImageType = dstP->imageType;
1955 /* Special case where we need to fill in alpha values */
1956 if (srcCMP->isDefaultCompatCM && dstCMP->isDefaultCompatCM) {
1957 int i;
1958 if (!srcCMP->supportsAlpha &&dstCMP->supportsAlpha) {
1959 hintP->addAlpha = TRUE(1);
1960 }
1961 for (i=0; i < srcCMP->numComponents; i++) {
1962 if (srcP->hints.colorOrder[i] != dstP->hints.colorOrder[i]){
1963 if (!srcCMP->isDefaultCM) {
1964 hintP->cvtSrcToDefault = TRUE(1);
1965 srcImageType = java_awt_image_BufferedImage_TYPE_INT_ARGB2L;
1966 }
1967 if (!dstCMP->isDefaultCM) {
1968 hintP->cvtToDst = TRUE(1);
1969 dstImageType = java_awt_image_BufferedImage_TYPE_INT_ARGB2L;
1970 }
1971
1972 break;
1973 }
1974 }
1975 }
1976 else if (srcCMP->cmType != INDEX_CM_TYPE3 &&
1977 !srcCMP->supportsAlpha && dstCMP->supportsAlpha)
1978 {
1979 /* We've already handled the index case. This is for the rest of the cases */
1980 srcImageType = java_awt_image_BufferedImage_TYPE_INT_ARGB2L;
1981 hintP->cvtSrcToDefault = TRUE(1);
1982 }
1983
1984 hintP->allocDefaultDst = FALSE(0);
1985 if (srcImageType == dstImageType) {
1986 /* Same image type so use it */
1987 hintP->cvtToDst = FALSE(0);
1988 }
1989 else if (srcImageType == TYPE_INT_RGB1L &&
1990 (dstImageType == TYPE_INT_ARGB2L ||
1991 dstImageType == TYPE_INT_ARGB_PRE3L)) {
1992 hintP->cvtToDst = FALSE(0);
1993 }
1994 else if (srcImageType == TYPE_INT_BGR4L &&
1995 (dstImageType == TYPE_4BYTE_ABGR6L ||
1996 dstImageType == TYPE_4BYTE_ABGR_PRE7L)) {
1997 hintP->cvtToDst = FALSE(0);
1998 }
1999 else if (srcP->hints.packing == dstP->hints.packing) {
2000 /* Now what? */
2001
2002 /* Check color order */
2003
2004 /* Check if just need to scale the data */
2005
2006 hintP->cvtToDst = TRUE(1);
2007 }
2008 else {
2009 /* Don't know what it is so convert it */
2010 hintP->allocDefaultDst = TRUE(1);
2011 hintP->cvtToDst = TRUE(1);
2012 }
2013 hintP->needToCopy = (ncomponents > nbands);
2014 }
2015
2016 return nbands;
2017}
2018
2019
2020static int
2021expandPacked(JNIEnv *env, BufImageS_t *img, ColorModelS_t *cmP,
2022 RasterS_t *rasterP, int component, unsigned char *bdataP) {
2023
2024 if (rasterP->rasterType == COMPONENT_RASTER_TYPE1) {
2025 switch (rasterP->dataType) {
2026 case BYTE_DATA_TYPE1:
2027 if (expandPackedBCR(env, rasterP, component, bdataP) < 0) {
2028 /* Must have been an error */
2029 return -1;
2030 }
2031 break;
2032
2033 case SHORT_DATA_TYPE2:
2034 if (expandPackedICR(env, rasterP, component, bdataP) < 0) {
2035 /* Must have been an error */
2036 return -1;
2037 }
2038 break;
2039
2040 case INT_DATA_TYPE3:
2041 if (expandPackedICR(env, rasterP, component, bdataP) < 0) {
2042 /* Must have been an error */
2043 return -1;
2044 }
2045 break;
2046
2047 default:
2048 /* REMIND: Return some sort of error */
2049 return -1;
2050 }
2051 }
2052 else {
2053 /* REMIND: Return some sort of error */
2054 return -1;
2055 }
2056
2057 return 0;
2058}
2059
2060#define NUM_LINES10 10
2061
2062static int
2063cvtCustomToDefault(JNIEnv *env, BufImageS_t *imageP, int component,
2064 unsigned char *dataP) {
2065 const RasterS_t *rasterP = &imageP->raster;
2066 const int w = rasterP->width;
2067 const int h = rasterP->height;
2068
2069 int y;
2070 jintArray jpixels = NULL((void*)0);
2071 jint *pixels;
2072 unsigned char *dP = dataP;
2073 int numLines = h > NUM_LINES10 ? NUM_LINES10 : h;
2074
2075 /* it is safe to calculate the scan length, because width has been verified
2076 * on creation of the mlib image
2077 */
2078 const int scanLength = w * 4;
2079
2080 int nbytes = 0;
2081 if (!SAFE_TO_MULT(numLines, scanLength)(((numLines) > 0) && ((scanLength) >= 0) &&
((0x7fffffff / (numLines)) > (scanLength)))) {
2082 return -1;
2083 }
2084
2085 nbytes = numLines * scanLength;
2086
2087 jpixels = (*env)->NewIntArray(env, nbytes);
2088 if (JNU_IsNull(env, jpixels)((jpixels) == ((void*)0))) {
2089 (*env)->ExceptionClear(env);
2090 JNU_ThrowOutOfMemoryError(env, "Out of Memory");
2091 return -1;
2092 }
2093
2094 for (y = 0; y < h; y += numLines) {
2095 if (y + numLines > h) {
2096 numLines = h - y;
2097 nbytes = numLines * scanLength;
2098 }
2099
2100 (*env)->CallObjectMethod(env, imageP->jimage,
2101 g_BImgGetRGBMID, 0, y,
2102 w, numLines,
2103 jpixels, 0, w);
2104 if ((*env)->ExceptionOccurred(env)) {
2105 (*env)->DeleteLocalRef(env, jpixels);
2106 return -1;
2107 }
2108
2109 pixels = (*env)->GetPrimitiveArrayCritical(env, jpixels, NULL((void*)0));
2110 if (pixels == NULL((void*)0)) {
2111 (*env)->DeleteLocalRef(env, jpixels);
2112 return -1;
2113 }
2114
2115 memcpy(dP, pixels, nbytes);
2116 dP += nbytes;
2117
2118 (*env)->ReleasePrimitiveArrayCritical(env, jpixels, pixels,
2119 JNI_ABORT2);
2120 }
2121
2122 /* Need to release the array */
2123 (*env)->DeleteLocalRef(env, jpixels);
2124
2125 return 0;
2126}
2127
2128static int
2129cvtDefaultToCustom(JNIEnv *env, BufImageS_t *imageP, int component,
2130 unsigned char *dataP) {
2131 const RasterS_t *rasterP = &imageP->raster;
2132 const int w = rasterP->width;
2133 const int h = rasterP->height;
2134
2135 int y;
2136 jintArray jpixels = NULL((void*)0);
2137 jint *pixels;
2138 unsigned char *dP = dataP;
2139 int numLines = h > NUM_LINES10 ? NUM_LINES10 : h;
2140
2141 /* it is safe to calculate the scan length, because width has been verified
2142 * on creation of the mlib image
2143 */
2144 const int scanLength = w * 4;
2145
2146 int nbytes = 0;
2147 if (!SAFE_TO_MULT(numLines, scanLength)(((numLines) > 0) && ((scanLength) >= 0) &&
((0x7fffffff / (numLines)) > (scanLength)))) {
2148 return -1;
2149 }
2150
2151 nbytes = numLines * scanLength;
2152
2153 jpixels = (*env)->NewIntArray(env, nbytes);
2154 if (JNU_IsNull(env, jpixels)((jpixels) == ((void*)0))) {
2155 (*env)->ExceptionClear(env);
2156 JNU_ThrowOutOfMemoryError(env, "Out of Memory");
2157 return -1;
2158 }
2159
2160 for (y = 0; y < h; y += numLines) {
2161 if (y + numLines > h) {
2162 numLines = h - y;
2163 nbytes = numLines * scanLength;
2164 }
2165
2166 pixels = (*env)->GetPrimitiveArrayCritical(env, jpixels, NULL((void*)0));
2167 if (pixels == NULL((void*)0)) {
2168 (*env)->DeleteLocalRef(env, jpixels);
2169 return -1;
2170 }
2171
2172 memcpy(pixels, dP, nbytes);
2173 dP += nbytes;
2174
2175 (*env)->ReleasePrimitiveArrayCritical(env, jpixels, pixels, 0);
2176
2177 (*env)->CallVoidMethod(env, imageP->jimage, g_BImgSetRGBMID, 0, y,
2178 w, numLines, jpixels,
2179 0, w);
2180 if ((*env)->ExceptionOccurred(env)) {
2181 (*env)->DeleteLocalRef(env, jpixels);
2182 return -1;
2183 }
2184 }
2185
2186 /* Need to release the array */
2187 (*env)->DeleteLocalRef(env, jpixels);
2188
2189 return 0;
2190}
2191
2192static int
2193allocateArray(JNIEnv *env, BufImageS_t *imageP,
2194 mlib_image **mlibImagePP, void **dataPP, int isSrc,
2195 int cvtToDefault, int addAlpha) {
2196 void *dataP;
2197 unsigned char *cDataP;
2198 RasterS_t *rasterP = &imageP->raster;
2199 ColorModelS_t *cmP = &imageP->cmodel;
2200 int dataType = BYTE_DATA_TYPE1;
2201 int width;
2202 int height;
2203 HintS_t *hintP = &imageP->hints;
2204 *dataPP = NULL((void*)0);
2205
2206 width = rasterP->width;
2207 height = rasterP->height;
2208
2209 /* Useful for convolution? */
2210 /* This code is zero'ed out so that it cannot be called */
2211
2212 /* To do this correctly, we need to expand src and dst in the */
2213 /* same direction up/down/left/right only if both can be expanded */
2214 /* in that direction. Expanding right and down is easy - */
2215 /* increment width. Expanding top and left requires bumping */
2216 /* around pointers and incrementing the width/height */
2217
2218#if 0
2219 if (0 && useEdges) {
2220 baseWidth = rasterP->baseRasterWidth;
2221 baseHeight = rasterP->baseRasterHeight;
2222 baseXoff = rasterP->baseOriginX;
2223 baseYoff = rasterP->baseOriginY;
2224
2225 if (rasterP->minX + rasterP->width < baseXoff + baseWidth) {
2226 /* Can use edge */
2227 width++;
2228 }
2229 if (rasterP->minY + rasterP->height < baseYoff + baseHeight) {
2230 /* Can use edge */
2231 height++;
2232 }
2233
2234 if (rasterP->minX > baseXoff ) {
2235 /* Can use edge */
2236 width++;
2237 /* NEED TO BUMP POINTER BACK A PIXELSTRIDE */
2238 }
2239 if (rasterP->minY > baseYoff) {
2240 /* Can use edge */
2241 height++;
2242 /* NEED TO BUMP POINTER BACK A SCANLINE */
2243 }
2244
2245
2246 }
2247#endif
2248 if (cvtToDefault) {
2249 int status = 0;
2250 *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, 4, width, height);
2251 if (*mlibImagePP == NULL((void*)0)) {
2252 return -1;
2253 }
2254 cDataP = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
2255 /* Make sure the image is cleared.
2256 * NB: the image dimension is already verified, so we can
2257 * safely calculate the length of the buffer.
2258 */
2259 memset(cDataP, 0, width*height*4);
2260
2261 if (!isSrc) {
2262 return 0;
2263 }
2264
2265 switch(imageP->cmodel.cmType) {
2266 case INDEX_CM_TYPE3:
2267 /* REMIND: Need to rearrange according to dst cm */
2268 /* Fix 4213160, 4184283 */
2269 if (rasterP->rasterType == COMPONENT_RASTER_TYPE1) {
2270 return expandICM(env, imageP, (unsigned int *)cDataP);
2271 }
2272 else {
2273 return cvtCustomToDefault(env, imageP, -1, cDataP);
2274 }
2275
2276 case DIRECT_CM_TYPE2:
2277 switch(imageP->raster.dataType) {
2278 case BYTE_DATA_TYPE1:
2279 return expandPackedBCRdefault(env, rasterP, -1, cDataP,
2280 !imageP->cmodel.supportsAlpha);
2281 case SHORT_DATA_TYPE2:
2282 return expandPackedSCRdefault(env, rasterP, -1, cDataP,
2283 !imageP->cmodel.supportsAlpha);
2284 case INT_DATA_TYPE3:
2285 return expandPackedICRdefault(env, rasterP, -1, cDataP,
2286 !imageP->cmodel.supportsAlpha);
2287 }
2288 } /* switch(imageP->cmodel.cmType) */
2289
2290 return cvtCustomToDefault(env, imageP, -1, cDataP);
2291 }
2292
2293 /* Interleaved with shared data */
2294 dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
2295 NULL((void*)0));
2296 if (dataP == NULL((void*)0)) {
2297 return -1;
2298 }
2299
2300 /* Means we need to fill in alpha */
2301 if (!cvtToDefault && addAlpha) {
2302 *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, 4, width, height);
2303 if (*mlibImagePP != NULL((void*)0)) {
2304 unsigned int *dstP = (unsigned int *)
2305 mlib_ImageGetData(*mlibImagePP);
2306 int dstride = (*mlibImagePP)->stride>>2;
2307 int sstride = hintP->sStride>>2;
2308 unsigned int *srcP = (unsigned int *)
2309 ((unsigned char *)dataP + hintP->dataOffset);
2310 unsigned int *dP, *sP;
2311 int x, y;
2312 for (y=0; y < height; y++, srcP += sstride, dstP += dstride){
2313 sP = srcP;
2314 dP = dstP;
2315 for (x=0; x < width; x++) {
2316 dP[x] = sP[x] | 0xff000000;
2317 }
2318 }
2319 }
2320 (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
2321 JNI_ABORT2);
2322 return 0;
2323 }
2324 else if ((hintP->packing & BYTE_INTERLEAVED(0x1 | 0x10)) == BYTE_INTERLEAVED(0x1 | 0x10)) {
2325 int nChans = (cmP->isDefaultCompatCM ? 4 : hintP->numChans);
2326 /* Easy case. It is or is similar to the default CM so use
2327 * the array. Must be byte data.
2328 */
2329 /* Create the medialib image */
2330 *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_BYTE,
2331 nChans,
2332 width,
2333 height,
2334 hintP->sStride,
2335 (unsigned char *)dataP
2336 + hintP->dataOffset);
2337 }
2338 else if ((hintP->packing & SHORT_INTERLEAVED(0x2 | 0x10)) == SHORT_INTERLEAVED(0x2 | 0x10)) {
2339 *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_SHORT,
2340 hintP->numChans,
2341 width,
2342 height,
2343 imageP->raster.scanlineStride*2,
2344 (unsigned short *)dataP
2345 + hintP->channelOffset);
2346 }
2347 else {
2348 /* Release the data array */
2349 (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
2350 JNI_ABORT2);
2351 return -1;
2352 }
2353
2354 *dataPP = dataP;
2355 return 0;
2356}
2357
2358static int
2359allocateRasterArray(JNIEnv *env, RasterS_t *rasterP,
2360 mlib_image **mlibImagePP, void **dataPP, int isSrc) {
2361 void *dataP;
2362 unsigned char *cDataP;
2363 int dataType = BYTE_DATA_TYPE1;
2364 int width;
2365 int height;
2366 int dataSize;
2367 int offset;
2368
2369 *dataPP = NULL((void*)0);
2370
2371 width = rasterP->width;
2372 height = rasterP->height;
2373
2374 if (rasterP->numBands <= 0 || rasterP->numBands > 4) {
2375 /* REMIND: Fix this */
2376 return -1;
2377 }
2378
2379 /* Useful for convolution? */
2380 /* This code is zero'ed out so that it cannot be called */
2381
2382 /* To do this correctly, we need to expand src and dst in the */
2383 /* same direction up/down/left/right only if both can be expanded */
2384 /* in that direction. Expanding right and down is easy - */
2385 /* increment width. Expanding top and left requires bumping */
2386 /* around pointers and incrementing the width/height */
2387
2388#if 0
2389 if (0 && useEdges) {
2390 baseWidth = rasterP->baseRasterWidth;
2391 baseHeight = rasterP->baseRasterHeight;
2392 baseXoff = rasterP->baseOriginX;
2393 baseYoff = rasterP->baseOriginY;
2394
2395 if (rasterP->minX + rasterP->width < baseXoff + baseWidth) {
2396 /* Can use edge */
2397 width++;
2398 }
2399 if (rasterP->minY + rasterP->height < baseYoff + baseHeight) {
2400 /* Can use edge */
2401 height++;
2402 }
2403
2404 if (rasterP->minX > baseXoff ) {
2405 /* Can use edge */
2406 width++;
2407 /* NEED TO BUMP POINTER BACK A PIXELSTRIDE */
2408 }
2409 if (rasterP->minY > baseYoff) {
2410 /* Can use edge */
2411 height++;
2412 /* NEED TO BUMP POINTER BACK A SCANLINE */
2413 }
2414
2415
2416 }
2417#endif
2418 switch (rasterP->type) {
2419 case sun_awt_image_IntegerComponentRaster_TYPE_INT_8BIT_SAMPLES10L:
2420 if (!((rasterP->chanOffsets[0] == 0 || SAFE_TO_ALLOC_2(rasterP->chanOffsets[0], 4)(((rasterP->chanOffsets[0]) > 0) && ((4) > 0
) && ((0x7fffffff / (rasterP->chanOffsets[0])) >
(4)))) &&
2421 SAFE_TO_ALLOC_2(width, 4)(((width) > 0) && ((4) > 0) && ((0x7fffffff
/ (width)) > (4))) &&
2422 SAFE_TO_ALLOC_3(rasterP->scanlineStride, height, 4)(((rasterP->scanlineStride) > 0) && ((height) >
0) && ((4) > 0) && (((0x7fffffff / (rasterP
->scanlineStride)) / (height)) > (4)))))
2423 {
2424 return -1;
2425 }
2426 offset = 4 * rasterP->chanOffsets[0];
2427 dataSize = 4 * (*env)->GetArrayLength(env, rasterP->jdata);
2428
2429 if (offset < 0 || offset >= dataSize ||
2430 width > rasterP->scanlineStride ||
2431 ((width + (height - 1) * rasterP->scanlineStride) * 4) > dataSize - offset)
2432 {
2433 // raster data buffer is too short
2434 return -1;
2435 }
2436 dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
2437 NULL((void*)0));
2438 if (dataP == NULL((void*)0)) {
2439 return -1;
2440 }
2441 *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_BYTE, 4,
2442 width, height,
2443 rasterP->scanlineStride*4,
2444 (unsigned char *)dataP + offset);
2445 *dataPP = dataP;
2446 return 0;
2447 case sun_awt_image_IntegerComponentRaster_TYPE_BYTE_SAMPLES1L:
2448 if (!(SAFE_TO_ALLOC_2(width, rasterP->numBands)(((width) > 0) && ((rasterP->numBands) > 0) &&
((0x7fffffff / (width)) > (rasterP->numBands))) &&
2449 SAFE_TO_ALLOC_2(rasterP->scanlineStride, height)(((rasterP->scanlineStride) > 0) && ((height) >
0) && ((0x7fffffff / (rasterP->scanlineStride)) >
(height)))))
2450 {
2451 return -1;
2452 }
2453 offset = rasterP->chanOffsets[0];
2454 dataSize = (*env)->GetArrayLength(env, rasterP->jdata);
2455
2456 if (offset < 0 || offset >= dataSize ||
2457 width * rasterP->numBands > rasterP->scanlineStride ||
2458 ((width * rasterP->numBands) +
2459 (height - 1) * rasterP->scanlineStride) > dataSize - offset)
2460 {
2461 // raster data buffer is too short
2462 return -1;
2463 }
2464 dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
2465 NULL((void*)0));
2466 if (dataP == NULL((void*)0)) {
2467 return -1;
2468 }
2469 *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_BYTE, rasterP->numBands,
2470 width, height,
2471 rasterP->scanlineStride,
2472 (unsigned char *)dataP + offset);
2473 *dataPP = dataP;
2474 return 0;
2475 case sun_awt_image_IntegerComponentRaster_TYPE_USHORT_SAMPLES2L:
2476 if (!((rasterP->chanOffsets[0] == 0 || SAFE_TO_ALLOC_2(rasterP->chanOffsets[0], 2)(((rasterP->chanOffsets[0]) > 0) && ((2) > 0
) && ((0x7fffffff / (rasterP->chanOffsets[0])) >
(2)))) &&
2477 SAFE_TO_ALLOC_3(width, rasterP->numBands, 2)(((width) > 0) && ((rasterP->numBands) > 0) &&
((2) > 0) && (((0x7fffffff / (width)) / (rasterP->
numBands)) > (2))) &&
2478 SAFE_TO_ALLOC_3(rasterP->scanlineStride, height, 2)(((rasterP->scanlineStride) > 0) && ((height) >
0) && ((2) > 0) && (((0x7fffffff / (rasterP
->scanlineStride)) / (height)) > (2)))))
2479 {
2480 return -1;
2481 }
2482 offset = rasterP->chanOffsets[0] * 2;
2483 dataSize = 2 * (*env)->GetArrayLength(env, rasterP->jdata);
2484
2485 if (offset < 0 || offset >= dataSize ||
2486 width * rasterP->numBands > rasterP->scanlineStride ||
2487 (((width * rasterP->numBands) +
2488 (height - 1) * rasterP->scanlineStride)) * 2 > dataSize - offset)
2489 {
2490 // raster data buffer is too short
2491 return -1;
2492 }
2493 dataP = (void *) (*env)->GetPrimitiveArrayCritical(env, rasterP->jdata,
2494 NULL((void*)0));
2495 if (dataP == NULL((void*)0)) {
2496 return -1;
2497 }
2498 *mlibImagePP = (*sMlibSysFns.createStructFP)(MLIB_SHORT,
2499 rasterP->numBands,
2500 width, height,
2501 rasterP->scanlineStride*2,
2502 (unsigned char *)dataP + offset);
2503 *dataPP = dataP;
2504 return 0;
2505
2506 case sun_awt_image_IntegerComponentRaster_TYPE_BYTE_PACKED_SAMPLES7L:
2507 *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
2508 width, height);
2509 if (*mlibImagePP == NULL((void*)0)) {
2510 return -1;
2511 }
2512 if (!isSrc) return 0;
2513 cDataP = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
2514 return expandPackedBCR(env, rasterP, -1, cDataP);
2515
2516 case sun_awt_image_IntegerComponentRaster_TYPE_USHORT_PACKED_SAMPLES8L:
2517 if (rasterP->sppsm.maxBitSize <= 8) {
2518 *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
2519 width, height);
2520 if (*mlibImagePP == NULL((void*)0)) {
2521 return -1;
2522 }
2523 if (!isSrc) return 0;
2524 cDataP = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
2525 return expandPackedSCR(env, rasterP, -1, cDataP);
2526 }
2527 break;
2528 case sun_awt_image_IntegerComponentRaster_TYPE_INT_PACKED_SAMPLES9L:
2529 if (rasterP->sppsm.maxBitSize <= 8) {
2530 *mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
2531 width, height);
2532 if (*mlibImagePP == NULL((void*)0)) {
2533 return -1;
2534 }
2535 if (!isSrc) return 0;
2536 cDataP = (unsigned char *) mlib_ImageGetData(*mlibImagePP);
2537 return expandPackedICR(env, rasterP, -1, cDataP);
2538 }
2539 break;
2540 }
2541
2542 /* Just expand it right now */
2543 switch (rasterP->dataType) {
2544 case BYTE_DATA_TYPE1:
2545 if ((*mlibImagePP = (*sMlibSysFns.createFP)(MLIB_BYTE, rasterP->numBands,
2546 width, height)) == NULL((void*)0)) {
2547 return -1;
2548 }
2549 if (isSrc) {
2550 if (awt_getPixels(env, rasterP, mlib_ImageGetData(*mlibImagePP)) < 0) {
2551 (*sMlibSysFns.deleteImageFP)(*mlibImagePP);
2552 return -1;
2553 }
2554 }
2555 break;
2556
2557 case SHORT_DATA_TYPE2:
2558 if ((*mlibImagePP = (*sMlibSysFns.createFP)(MLIB_SHORT,
2559 rasterP->numBands,
2560 width, height)) == NULL((void*)0)) {
2561 return -1;
2562 }
2563 if (isSrc) {
2564 if (awt_getPixels(env, rasterP, mlib_ImageGetData(*mlibImagePP)) < 0) {
2565 (*sMlibSysFns.deleteImageFP)(*mlibImagePP);
2566 return -1;
2567 }
2568 }
2569 break;
2570
2571 default:
2572 return -1;
2573 }
2574 return 0;
2575}
2576
2577static void
2578freeArray(JNIEnv *env, BufImageS_t *srcimageP, mlib_image *srcmlibImP,
2579 void *srcdataP, BufImageS_t *dstimageP, mlib_image *dstmlibImP,
2580 void *dstdataP) {
2581 jobject srcJdata = (srcimageP != NULL((void*)0) ? srcimageP->raster.jdata : NULL((void*)0));
2582 jobject dstJdata = (dstimageP != NULL((void*)0) ? dstimageP->raster.jdata : NULL((void*)0));
2583 freeDataArray(env, srcJdata, srcmlibImP, srcdataP,
2584 dstJdata, dstmlibImP, dstdataP);
2585}
2586static void
2587freeDataArray(JNIEnv *env, jobject srcJdata, mlib_image *srcmlibImP,
2588 void *srcdataP, jobject dstJdata, mlib_image *dstmlibImP,
2589 void *dstdataP)
2590{
2591 /* Free the medialib image */
2592 if (srcmlibImP) {
2593 (*sMlibSysFns.deleteImageFP)(srcmlibImP);
2594 }
2595
2596 /* Release the array */
2597 if (srcdataP) {
2598 (*env)->ReleasePrimitiveArrayCritical(env, srcJdata,
2599 srcdataP, JNI_ABORT2);
2600 }
2601
2602 /* Free the medialib image */
2603 if (dstmlibImP) {
2604 (*sMlibSysFns.deleteImageFP)(dstmlibImP);
2605 }
2606
2607 /* Release the array */
2608 if (dstdataP) {
2609 (*env)->ReleasePrimitiveArrayCritical(env, dstJdata,
2610 dstdataP, 0);
2611 }
2612}
2613
2614#define ERR_BAD_IMAGE_LAYOUT(-2) (-2)
2615
2616#define CHECK_DST_ARRAY(start_offset, elements_per_scan, elements_per_pixel)do { int offset = (start_offset); int lastScanOffset; if (!((
((elements_per_scan)) > 0) && (((rasterP->height
- 1)) >= 0) && ((0x7fffffff / ((elements_per_scan
))) > ((rasterP->height - 1))))) { return (-2); } lastScanOffset
= (elements_per_scan) * (rasterP->height - 1); if (!(((offset
) >= 0) && ((lastScanOffset) >= 0) && (
(0x7fffffff - (offset)) > (lastScanOffset)))) { return (-2
); } lastScanOffset += offset; if (!((((elements_per_pixel)) >
0) && ((rasterP->width) >= 0) && ((0x7fffffff
/ ((elements_per_pixel))) > (rasterP->width)))) { return
(-2); } offset = (elements_per_pixel) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0); \
2617 do { \
2618 int offset = (start_offset); \
2619 int lastScanOffset; \
2620 \
2621 if (!SAFE_TO_MULT((elements_per_scan), \((((elements_per_scan)) > 0) && (((rasterP->height
- 1)) >= 0) && ((0x7fffffff / ((elements_per_scan
))) > ((rasterP->height - 1))))
2622 (rasterP->height - 1))((((elements_per_scan)) > 0) && (((rasterP->height
- 1)) >= 0) && ((0x7fffffff / ((elements_per_scan
))) > ((rasterP->height - 1))))) \
2623 { \
2624 return ERR_BAD_IMAGE_LAYOUT(-2); \
2625 } \
2626 lastScanOffset = (elements_per_scan) * (rasterP->height - 1); \
2627 \
2628 if (!SAFE_TO_ADD(offset, lastScanOffset)(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { \
2629 return ERR_BAD_IMAGE_LAYOUT(-2); \
2630 } \
2631 lastScanOffset += offset; \
2632 \
2633 if (!SAFE_TO_MULT((elements_per_pixel), rasterP->width)((((elements_per_pixel)) > 0) && ((rasterP->width
) >= 0) && ((0x7fffffff / ((elements_per_pixel))) >
(rasterP->width)))) { \
2634 return ERR_BAD_IMAGE_LAYOUT(-2); \
2635 } \
2636 offset = (elements_per_pixel) * rasterP->width; \
2637 \
2638 if (!SAFE_TO_ADD(offset, lastScanOffset)(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { \
2639 return ERR_BAD_IMAGE_LAYOUT(-2); \
2640 } \
2641 lastScanOffset += offset; \
2642 \
2643 if (dataArrayLength < lastScanOffset) { \
2644 return ERR_BAD_IMAGE_LAYOUT(-2); \
2645 } \
2646 } while(0); \
2647
2648static int
2649storeImageArray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
2650 mlib_image *mlibImP) {
2651 int mStride;
2652 unsigned char *cmDataP, *dataP, *cDataP;
2653 HintS_t *hintP = &dstP->hints;
2654 RasterS_t *rasterP = &dstP->raster;
2655 jsize dataArrayLength = (*env)->GetArrayLength(env, rasterP->jdata);
2656 int y;
2657
2658 /* REMIND: Store mlib data type? */
2659
2660 /* Check if it is an IndexColorModel */
2661 if (dstP->cmodel.cmType == INDEX_CM_TYPE3) {
2662 if (dstP->raster.rasterType == COMPONENT_RASTER_TYPE1) {
2663 return storeICMarray(env, srcP, dstP, mlibImP);
2664 }
2665 else {
2666 /* Packed or some other custom raster */
2667 cmDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
2668 return cvtDefaultToCustom(env, dstP, -1, cmDataP);
2669 }
2670 }
2671
2672 if (hintP->packing == BYTE_INTERLEAVED(0x1 | 0x10)) {
2673 /* Write it back to the destination */
2674 if (rasterP->dataType != BYTE_DATA_TYPE1) {
2675 /* We are working with a raster which was marked
2676 as a byte interleaved due to performance reasons.
2677 So, we have to convert the length of the data
2678 array to bytes as well.
2679 */
2680 if (!SAFE_TO_MULT(rasterP->dataSize, dataArrayLength)(((rasterP->dataSize) > 0) && ((dataArrayLength
) >= 0) && ((0x7fffffff / (rasterP->dataSize)) >
(dataArrayLength)))) {
2681 return ERR_BAD_IMAGE_LAYOUT(-2);
2682 }
2683 dataArrayLength *= rasterP->dataSize;
2684 }
2685
2686 CHECK_DST_ARRAY(hintP->dataOffset, hintP->sStride, hintP->numChans)do { int offset = (hintP->dataOffset); int lastScanOffset;
if (!((((hintP->sStride)) > 0) && (((rasterP->
height - 1)) >= 0) && ((0x7fffffff / ((hintP->sStride
))) > ((rasterP->height - 1))))) { return (-2); } lastScanOffset
= (hintP->sStride) * (rasterP->height - 1); if (!(((offset
) >= 0) && ((lastScanOffset) >= 0) && (
(0x7fffffff - (offset)) > (lastScanOffset)))) { return (-2
); } lastScanOffset += offset; if (!((((hintP->numChans)) >
0) && ((rasterP->width) >= 0) && ((0x7fffffff
/ ((hintP->numChans))) > (rasterP->width)))) { return
(-2); } offset = (hintP->numChans) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
2687 cmDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
2688 mStride = mlib_ImageGetStride(mlibImP);
2689 dataP = (unsigned char *)(*env)->GetPrimitiveArrayCritical(env,
2690 rasterP->jdata, NULL((void*)0));
2691 if (dataP == NULL((void*)0)) return 0;
2692 cDataP = dataP + hintP->dataOffset;
2693 for (y=0; y < rasterP->height;
2694 y++, cmDataP += mStride, cDataP += hintP->sStride)
2695 {
2696 memcpy(cDataP, cmDataP, rasterP->width*hintP->numChans);
2697 }
2698 (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
2699 JNI_ABORT2);
2700 }
2701 else if (dstP->cmodel.cmType == DIRECT_CM_TYPE2) {
2702 /* Just need to move bits */
2703 if (mlibImP->type == MLIB_BYTE) {
2704 if (dstP->hints.packing == PACKED_BYTE_INTER(0x5 | 0x10)) {
2705 return setPackedBCRdefault(env, rasterP, -1,
2706 (unsigned char *) mlibImP->data,
2707 dstP->cmodel.supportsAlpha);
2708 } else if (dstP->hints.packing == PACKED_SHORT_INTER(0x4 | 0x10)) {
2709 return setPackedSCRdefault(env, rasterP, -1,
2710 (unsigned char *) mlibImP->data,
2711 dstP->cmodel.supportsAlpha);
2712 } else if (dstP->hints.packing == PACKED_INT_INTER(0x3 | 0x10)) {
2713 return setPackedICRdefault(env, rasterP, -1,
2714 (unsigned char *) mlibImP->data,
2715 dstP->cmodel.supportsAlpha);
2716 }
2717 }
2718 else if (mlibImP->type == MLIB_SHORT) {
2719 return setPixelsFormMlibImage(env, rasterP, mlibImP);
2720 }
2721 }
2722 else {
2723 return cvtDefaultToCustom(env, dstP, -1,
2724 (unsigned char *)mlibImP->data);
2725 }
2726
2727 return 0;
2728}
2729
2730static int
2731storeRasterArray(JNIEnv *env, RasterS_t *srcP, RasterS_t *dstP,
2732 mlib_image *mlibImP) {
2733 unsigned char *cDataP;
2734
2735 switch(dstP->type) {
2736 case sun_awt_image_IntegerComponentRaster_TYPE_BYTE_PACKED_SAMPLES7L:
2737 cDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
2738 return setPackedBCR(env, dstP, -1, cDataP);
2739
2740 case sun_awt_image_IntegerComponentRaster_TYPE_USHORT_PACKED_SAMPLES8L:
2741 if (dstP->sppsm.maxBitSize <= 8) {
2742 cDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
2743 return setPackedSCR(env, dstP, -1, cDataP);
2744 }
2745 break;
2746 case sun_awt_image_IntegerComponentRaster_TYPE_INT_PACKED_SAMPLES9L:
2747 if (dstP->sppsm.maxBitSize <= 8) {
2748 cDataP = (unsigned char *) mlib_ImageGetData(mlibImP);
2749 return setPackedICR(env, dstP, -1, cDataP);
2750 }
2751 }
2752
2753 return -1;
2754}
2755
2756
2757static int
2758storeICMarray(JNIEnv *env, BufImageS_t *srcP, BufImageS_t *dstP,
2759 mlib_image *mlibImP)
2760{
2761 int *argb;
2762 int x, y;
2763 unsigned char *dataP, *cDataP, *cP;
2764 unsigned char *sP;
2765 int aIdx, rIdx, gIdx, bIdx;
2766 ColorModelS_t *cmodelP = &dstP->cmodel;
2767 RasterS_t *rasterP = &dstP->raster;
2768
2769 /* REMIND: Only works for RGB */
2770 if (cmodelP->csType != java_awt_color_ColorSpace_TYPE_RGB5L) {
2771 JNU_ThrowInternalError(env, "Writing to non-RGB images not implemented yet");
2772 return -1;
2773 }
2774
2775 if (srcP->imageType == java_awt_image_BufferedImage_TYPE_INT_ARGB2L ||
2776 srcP->imageType == java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE3L ||
2777 srcP->imageType == java_awt_image_BufferedImage_TYPE_INT_RGB1L)
2778 {
2779 aIdx = 0;
2780 rIdx = 1;
2781 gIdx = 2;
2782 bIdx = 3;
2783 }
2784 else if (srcP->imageType ==java_awt_image_BufferedImage_TYPE_4BYTE_ABGR6L||
2785 srcP->imageType == java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE7L)
2786 {
2787 aIdx = 0;
2788 rIdx = 3;
2789 gIdx = 2;
2790 bIdx = 1;
2791 }
2792 else if (srcP->imageType == java_awt_image_BufferedImage_TYPE_3BYTE_BGR5L){
2793 rIdx = 2;
2794 gIdx = 1;
2795 bIdx = 0;
2796 aIdx = 0; /* Ignored */
2797 }
2798 else if (srcP->cmodel.cmType == INDEX_CM_TYPE3) {
2799 rIdx = 0;
2800 gIdx = 1;
2801 bIdx = 2;
2802 aIdx = 3; /* Use supportsAlpha to see if it is really there */
2803 }
2804 else {
2805 return -1;
2806 }
2807
2808 /* Lock down the destination raster */
2809 dataP = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env,
2810 rasterP->jdata, NULL((void*)0));
2811 if (dataP == NULL((void*)0)) {
2812 return -1;
2813 }
2814 argb = (*env)->GetPrimitiveArrayCritical(env, cmodelP->jrgb, NULL((void*)0));
2815 if (argb == NULL((void*)0)) {
2816 (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
2817 JNI_ABORT2);
2818 return -1;
2819 }
2820
2821 cDataP = dataP + dstP->hints.dataOffset;
2822 sP = (unsigned char *) mlib_ImageGetData(mlibImP);
2823
2824 for (y=0; y < rasterP->height; y++, cDataP += rasterP->scanlineStride) {
2825 cP = cDataP;
2826 for (x=0; x < rasterP->width; x++, cP += rasterP->pixelStride) {
2827 *cP = colorMatch(sP[rIdx], sP[gIdx], sP[bIdx], sP[aIdx],
2828 (unsigned char *)argb, cmodelP->mapSize);
2829 sP += cmodelP->numComponents;
2830 }
2831 }
2832
2833 (*env)->ReleasePrimitiveArrayCritical(env, cmodelP->jrgb, argb, JNI_ABORT2);
2834 (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata, dataP,
2835 JNI_ABORT2);
2836 return -1;
2837}
2838
2839static int expandICM(JNIEnv *env, BufImageS_t *imageP, unsigned int *mDataP)
2840{
2841 ColorModelS_t *cmP = &imageP->cmodel;
2842 RasterS_t *rasterP = &imageP->raster;
2843 HintS_t *hintP = &imageP->hints;
2844 int *rgb;
2845 int status = 0;
2846 unsigned char *dataP, *cP;
2847 unsigned int *mP;
2848 int width = rasterP->width;
2849 int height = rasterP->height;
2850 int x, y;
2851
2852 /* Need to grab the lookup tables. Right now only bytes */
2853 rgb = (int *) (*env)->GetPrimitiveArrayCritical(env, cmP->jrgb, NULL((void*)0));
2854 CHECK_NULL_RETURN(rgb, -1)do { if ((rgb) == ((void*)0)) { return (-1); } } while (0);
2855
2856 /* Interleaved with shared data */
2857 dataP = (void *) (*env)->GetPrimitiveArrayCritical(env,
2858 rasterP->jdata, NULL((void*)0));
2859 if (dataP == NULL((void*)0)) {
2860 /* Release the lookup tables */
2861 (*env)->ReleasePrimitiveArrayCritical(env, cmP->jrgb, rgb, JNI_ABORT2);
2862 return -1;
2863 }
2864
2865 if (rasterP->dataType == BYTE_DATA_TYPE1) {
2866 unsigned char *cDataP = ((unsigned char *)dataP) + hintP->dataOffset;
2867
2868 for (y=0; y < height; y++) {
2869 mP = mDataP;
2870 cP = cDataP;
2871 for (x=0; x < width; x++, cP += rasterP->pixelStride) {
2872 *mP++ = rgb[*cP];
2873 }
2874 mDataP += width;
2875 cDataP += rasterP->scanlineStride;
2876 }
2877 }
2878 else if (rasterP->dataType == SHORT_DATA_TYPE2) {
2879 unsigned short *sDataP, *sP;
2880 sDataP = ((unsigned short *)dataP) + hintP->channelOffset;
2881
2882 for (y=0; y < height; y++) {
2883 mP = mDataP;
2884 sP = sDataP;
2885 for (x=0; x < width; x++, sP+=rasterP->pixelStride) {
2886 *mP++ = rgb[*sP];
2887 }
2888 mDataP += width;
2889 sDataP += rasterP->scanlineStride;
2890 }
2891 }
2892 else {
2893 /* Unknown type */
2894 status = -1;
2895 }
2896 /* Release the lookup table data */
2897 (*env)->ReleasePrimitiveArrayCritical(env, imageP->cmodel.jrgb,
2898 rgb, JNI_ABORT2);
2899 /* Release the data array */
2900 (*env)->ReleasePrimitiveArrayCritical(env, rasterP->jdata,
2901 dataP, JNI_ABORT2);
2902 return status;
2903}
2904/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
2905static int expandPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
2906 unsigned char *outDataP)
2907{
2908 int x, y, c;
2909 unsigned char *outP = outDataP;
2910 unsigned char *lineInP, *inP;
2911 jarray jInDataP;
2912 jint *inDataP;
2913 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
2914
2915 if (rasterP->numBands > MAX_NUMBANDS32) {
2916 return -1;
2917 }
2918
2919 /* Grab data ptr, strides, offsets from raster */
2920 jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
2921 inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
2922 if (inDataP == NULL((void*)0)) {
2923 return -1;
2924 }
2925 lineInP = (unsigned char *)inDataP + rasterP->chanOffsets[0];
2926
2927 if (component < 0) {
2928 for (c=0; c < rasterP->numBands; c++) {
2929 roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
2930 if (roff[c] < 0) {
2931 loff[c] = -roff[c];
2932 roff[c] = 0;
2933 }
2934 else loff[c] = 0;
2935 }
2936 /* Convert the all bands */
2937 if (rasterP->numBands < 4) {
2938 /* Need to put in alpha */
2939 for (y=0; y < rasterP->height; y++) {
2940 inP = lineInP;
2941 for (x=0; x < rasterP->width; x++) {
2942 for (c=0; c < rasterP->numBands; c++) {
2943 *outP++ = (unsigned char)
2944 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
2945 <<loff[c]);
2946 }
2947 inP++;
2948 }
2949 lineInP += rasterP->scanlineStride;
2950 }
2951 }
2952 else {
2953 for (y=0; y < rasterP->height; y++) {
2954 inP = lineInP;
2955 for (x=0; x < rasterP->width; x++) {
2956 for (c=0; c < rasterP->numBands; c++) {
2957 *outP++ = (unsigned char)
2958 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
2959 <<loff[c]);
2960 }
2961 inP++;
2962 }
2963 lineInP += rasterP->scanlineStride;
2964 }
2965 }
2966 }
2967 else {
2968 c = component;
2969 roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
2970 if (roff[0] < 0) {
2971 loff[0] = -roff[0];
2972 roff[0] = 0;
2973 }
2974 else loff[c] = 0;
2975 for (y=0; y < rasterP->height; y++) {
2976 inP = lineInP;
2977 for (x=0; x < rasterP->width; x++) {
2978 *outP++ = (unsigned char)
2979 ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
2980 inP++;
2981 }
2982 lineInP += rasterP->scanlineStride;
2983 }
2984 }
2985
2986 (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);
2987
2988 return 0;
2989}
2990
2991/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
2992static int expandPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
2993 int component, unsigned char *outDataP,
2994 int forceAlpha)
2995{
2996 int x, y, c;
2997 unsigned char *outP = outDataP;
2998 unsigned char *lineInP, *inP;
2999 jarray jInDataP;
3000 jint *inDataP;
3001 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3002 int numBands = rasterP->numBands - (forceAlpha ? 0 : 1);
3003 int a = numBands;
3004
3005 if (rasterP->numBands > MAX_NUMBANDS32) {
3006 return -1;
3007 }
3008
3009 /* Grab data ptr, strides, offsets from raster */
3010 jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
3011 inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
3012 if (inDataP == NULL((void*)0)) {
3013 return -1;
3014 }
3015 lineInP = (unsigned char *)inDataP + rasterP->chanOffsets[0];
3016
3017 if (component < 0) {
3018 for (c=0; c < rasterP->numBands; c++) {
3019 roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3020 if (roff[c] < 0) {
3021 loff[c] = -roff[c];
3022 roff[c] = 0;
3023 }
3024 else loff[c] = 0;
3025 }
3026
3027 /* Need to put in alpha */
3028 if (forceAlpha) {
3029 for (y=0; y < rasterP->height; y++) {
3030 inP = lineInP;
3031 for (x=0; x < rasterP->width; x++) {
3032 *outP++ = 0xff;
3033 for (c=0; c < numBands; c++) {
3034 *outP++ = (unsigned char)
3035 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3036 <<loff[c]);
3037 }
3038 inP++;
3039 }
3040 lineInP += rasterP->scanlineStride;
3041 }
3042 }
3043 else {
3044 for (y=0; y < rasterP->height; y++) {
3045 inP = lineInP;
3046 for (x=0; x < rasterP->width; x++) {
3047 *outP++ = (unsigned char)
3048 (((*inP&rasterP->sppsm.maskArray[a]) >> roff[a])
3049 <<loff[a]);
3050 for (c=0; c < numBands; c++) {
3051 *outP++ = (unsigned char)
3052 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3053 <<loff[c]);
3054 }
3055 inP++;
3056 }
3057 lineInP += rasterP->scanlineStride;
3058 }
3059 }
3060 }
3061 else {
3062 c = component;
3063 roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3064 if (roff[0] < 0) {
3065 loff[0] = -roff[0];
3066 roff[0] = 0;
3067 }
3068 else loff[c] = 0;
3069 for (y=0; y < rasterP->height; y++) {
3070 inP = lineInP;
3071 for (x=0; x < rasterP->width; x++) {
3072 *outP++ = (unsigned char)
3073 ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
3074 inP++;
3075 }
3076 lineInP += rasterP->scanlineStride;
3077 }
3078 }
3079
3080 (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);
3081
3082 return 0;
3083}
3084
3085/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3086static int expandPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
3087 unsigned char *outDataP)
3088{
3089 int x, y, c;
3090 unsigned char *outP = outDataP;
3091 unsigned short *lineInP, *inP;
3092 jarray jInDataP;
3093 jint *inDataP;
3094 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3095
3096 if (rasterP->numBands > MAX_NUMBANDS32) {
3097 return -1;
3098 }
3099
3100 /* Grab data ptr, strides, offsets from raster */
3101 jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
3102 inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
3103 if (inDataP == NULL((void*)0)) {
3104 return -1;
3105 }
3106 lineInP = (unsigned short *)inDataP + rasterP->chanOffsets[0];
3107
3108 if (component < 0) {
3109 for (c=0; c < rasterP->numBands; c++) {
3110 roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3111 if (roff[c] < 0) {
3112 loff[c] = -roff[c];
3113 roff[c] = 0;
3114 }
3115 else loff[c] = 0;
3116 }
3117 /* Convert the all bands */
3118 if (rasterP->numBands < 4) {
3119 /* Need to put in alpha */
3120 for (y=0; y < rasterP->height; y++) {
3121 inP = lineInP;
3122 for (x=0; x < rasterP->width; x++) {
3123 for (c=0; c < rasterP->numBands; c++) {
3124 /*
3125 *Not correct. Might need to unpremult,
3126 * shift, etc
3127 */
3128 *outP++ = (unsigned char)
3129 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3130 <<loff[c]);
3131 }
3132 inP++;
3133 }
3134 lineInP += rasterP->scanlineStride;
3135 }
3136 } else {
3137 for (y=0; y < rasterP->height; y++) {
3138 inP = lineInP;
3139 for (x=0; x < rasterP->width; x++) {
3140 for (c=0; c < rasterP->numBands; c++) {
3141 /*
3142 *Not correct. Might need to unpremult,
3143 * shift, etc
3144 */
3145 *outP++ = (unsigned char)
3146 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3147 <<loff[c]);
3148 }
3149 inP++;
3150 }
3151 lineInP += rasterP->scanlineStride;
3152 }
3153 }
3154 }
3155 else {
3156 c = component;
3157 roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3158 if (roff[0] < 0) {
3159 loff[0] = -roff[0];
3160 roff[0] = 0;
3161 }
3162 else loff[c] = 0;
3163 for (y=0; y < rasterP->height; y++) {
3164 inP = lineInP;
3165 for (x=0; x < rasterP->width; x++) {
3166 *outP++ = (unsigned char)
3167 ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
3168 inP++;
3169 }
3170 lineInP += rasterP->scanlineStride;
3171 }
3172 }
3173
3174 (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);
3175
3176 return 0;
3177}
3178
3179/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3180static int expandPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
3181 int component, unsigned char *outDataP,
3182 int forceAlpha)
3183{
3184 int x, y, c;
3185 unsigned char *outP = outDataP;
3186 unsigned short *lineInP, *inP;
3187 jarray jInDataP;
3188 jint *inDataP;
3189 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3190 int numBands = rasterP->numBands - (forceAlpha ? 0 : 1);
3191 int a = numBands;
3192
3193 if (rasterP->numBands > MAX_NUMBANDS32) {
3194 return -1;
3195 }
3196
3197 /* Grab data ptr, strides, offsets from raster */
3198 jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
3199 inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
3200 if (inDataP == NULL((void*)0)) {
3201 return -1;
3202 }
3203 lineInP = (unsigned short *)inDataP + rasterP->chanOffsets[0];
3204
3205 if (component < 0) {
3206 for (c=0; c < rasterP->numBands; c++) {
3207 roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3208 if (roff[c] < 0) {
3209 loff[c] = -roff[c];
3210 roff[c] = 0;
3211 }
3212 else loff[c] = 0;
3213 }
3214
3215 /* Need to put in alpha */
3216 if (forceAlpha) {
3217 for (y=0; y < rasterP->height; y++) {
3218 inP = lineInP;
3219 for (x=0; x < rasterP->width; x++) {
3220 *outP++ = 0xff;
3221 for (c=0; c < numBands; c++) {
3222 /*
3223 * Not correct. Might need to unpremult,
3224 * shift, etc
3225 */
3226 *outP++ = (unsigned char)
3227 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3228 <<loff[c]);
3229 }
3230 inP++;
3231 }
3232 lineInP += rasterP->scanlineStride;
3233 }
3234 }
3235 else {
3236 for (y=0; y < rasterP->height; y++) {
3237 inP = lineInP;
3238 for (x=0; x < rasterP->width; x++) {
3239 *outP++ = (unsigned char)
3240 (((*inP&rasterP->sppsm.maskArray[a]) >> roff[a])
3241 <<loff[a]);
3242 for (c=0; c < numBands; c++) {
3243 /*
3244 * Not correct. Might need to
3245 * unpremult, shift, etc
3246 */
3247 *outP++ = (unsigned char)
3248 (((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3249 <<loff[c]);
3250 }
3251 inP++;
3252 }
3253 lineInP += rasterP->scanlineStride;
3254 }
3255 }
3256 }
3257 else {
3258 c = component;
3259 roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3260 if (roff[0] < 0) {
3261 loff[0] = -roff[0];
3262 roff[0] = 0;
3263 }
3264 else loff[c] = 0;
3265 for (y=0; y < rasterP->height; y++) {
3266 inP = lineInP;
3267 for (x=0; x < rasterP->width; x++) {
3268 *outP++ = (unsigned char)
3269 ((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0];
3270 inP++;
3271 }
3272 lineInP += rasterP->scanlineStride;
3273 }
3274 }
3275
3276 (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);
3277
3278 return 0;
3279
3280}
3281
3282/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3283static int expandPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
3284 unsigned char *outDataP)
3285{
3286 int x, y, c;
3287 unsigned char *outP = outDataP;
3288 unsigned int *lineInP, *inP;
3289 jarray jInDataP;
3290 jint *inDataP;
3291 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3292
3293 if (rasterP->numBands > MAX_NUMBANDS32) {
3294 return -1;
3295 }
3296
3297 /* Grab data ptr, strides, offsets from raster */
3298 jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
3299 inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
3300 if (inDataP == NULL((void*)0)) {
3301 return -1;
3302 }
3303 lineInP = (unsigned int *)inDataP + rasterP->chanOffsets[0];
3304
3305 if (component < 0) {
3306 for (c=0; c < rasterP->numBands; c++) {
3307 roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3308 if (roff[c] < 0) {
3309 loff[c] = -roff[c];
3310 roff[c] = 0;
3311 }
3312 else loff[c] = 0;
3313 }
3314 /* Convert the all bands */
3315 if (rasterP->numBands < 4) {
3316 for (y=0; y < rasterP->height; y++) {
3317 inP = lineInP;
3318 for (x=0; x < rasterP->width; x++) {
3319 for (c=0; c < rasterP->numBands; c++) {
3320 /*
3321 * Not correct. Might need to unpremult,
3322 * shift, etc
3323 */
3324 *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3325 <<loff[c]);
3326 }
3327 inP++;
3328 }
3329 lineInP += rasterP->scanlineStride;
3330 }
3331 }
3332 else {
3333 for (y=0; y < rasterP->height; y++) {
3334 inP = lineInP;
3335 for (x=0; x < rasterP->width; x++) {
3336 for (c=0; c < rasterP->numBands; c++) {
3337 /*
3338 * Not correct. Might need to
3339 * unpremult, shift, etc
3340 */
3341 *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3342 <<loff[c]);
3343 }
3344 inP++;
3345 }
3346 lineInP += rasterP->scanlineStride;
3347 }
3348 }
3349 }
3350 else {
3351 c = component;
3352 roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3353 if (roff[0] < 0) {
3354 loff[0] = -roff[0];
3355 roff[0] = 0;
3356 }
3357 else loff[c] = 0;
3358 for (y=0; y < rasterP->height; y++) {
3359 inP = lineInP;
3360 for (x=0; x < rasterP->width; x++) {
3361 *outP++ = (unsigned char)(((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0]);
3362 inP++;
3363 }
3364 lineInP += rasterP->scanlineStride;
3365 }
3366 }
3367
3368 (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);
3369
3370 return 0;
3371}
3372
3373/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3374static int expandPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
3375 int component, unsigned char *outDataP,
3376 int forceAlpha)
3377{
3378 int x, y, c;
3379 unsigned char *outP = outDataP;
3380 unsigned int *lineInP, *inP;
3381 jarray jInDataP;
3382 jint *inDataP;
3383 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3384 int numBands = rasterP->numBands - (forceAlpha ? 0 : 1);
1
Assuming 'forceAlpha' is 0
→
2
←
'?' condition is false
→
3385 int a = numBands;
3386
3387 if (rasterP->numBands > MAX_NUMBANDS32) {
3
←
Assuming field 'numBands' is <= MAX_NUMBANDS
→
4
←
Taking false branch
→
3388 return -1;
3389 }
3390
3391 /* Grab data ptr, strides, offsets from raster */
3392 jInDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
3393 inDataP = (*env)->GetPrimitiveArrayCritical(env, jInDataP, 0);
3394 if (inDataP == NULL((void*)0)) {
5
←
Assuming 'inDataP' is not equal to NULL
→
6
←
Taking false branch
→
3395 return -1;
3396 }
3397 lineInP = (unsigned int *)inDataP + rasterP->chanOffsets[0];
3398
3399 if (component < 0) {
7
←
Assuming 'component' is < 0
→
8
←
Taking true branch
→
3400 for (c=0; c < rasterP->numBands; c++) {
9
←
Assuming 'c' is >= field 'numBands'
→
10
←
Loop condition is false. Execution continues on line 3410
→
3401 roff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3402 if (roff[c] < 0) {
3403 loff[c] = -roff[c];
3404 roff[c] = 0;
3405 }
3406 else loff[c] = 0;
3407 }
3408
3409 /* Need to put in alpha */
3410 if (forceAlpha
10.1
'forceAlpha' is 0
) {
11
←
Taking false branch
→
3411 for (y=0; y < rasterP->height; y++) {
3412 inP = lineInP;
3413 for (x=0; x < rasterP->width; x++) {
3414 *outP++ = 0xff;
3415 for (c=0; c < numBands; c++) {
3416 /*
3417 * Not correct. Might need to unpremult,
3418 * shift, etc
3419 */
3420 *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
3421 <<loff[c]);
3422 }
3423 inP++;
3424 }
3425 lineInP += rasterP->scanlineStride;
3426 }
3427 }
3428 else {
3429 for (y=0; y < rasterP->height; y++) {
12
←
Assuming 'y' is < field 'height'
→
13
←
Loop condition is true. Entering loop body
→
3430 inP = lineInP;
3431 for (x=0; x < rasterP->width; x++) {
14
←
Assuming 'x' is < field 'width'
→
15
←
Loop condition is true. Entering loop body
→
3432 *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[a]) >> roff[a])
3433 <<loff[a]);
3434 for (c=0; c < numBands; c++) {
16
←
The value 0 is assigned to 'c'
→
17
←
Assuming 'c' is < 'numBands'
→
18
←
Loop condition is true. Entering loop body
→
3435 /*
3436 * Not correct. Might need to
3437 * unpremult, shift, etc
3438 */
3439 *outP++ = (unsigned char)(((*inP&rasterP->sppsm.maskArray[c]) >> roff[c])
19
←
The right operand of '>>' is a garbage value
3440 <<loff[c]);
3441 }
3442 inP++;
3443 }
3444 lineInP += rasterP->scanlineStride;
3445 }
3446 }
3447 }
3448 else {
3449 c = component;
3450 roff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3451 if (roff[0] < 0) {
3452 loff[0] = -roff[0];
3453 roff[0] = 0;
3454 }
3455 else loff[c] = 0;
3456 for (y=0; y < rasterP->height; y++) {
3457 inP = lineInP;
3458 for (x=0; x < rasterP->width; x++) {
3459 *outP++ = (unsigned char)(((*inP & rasterP->sppsm.maskArray[c])>>roff[0])<<loff[0]);
3460 inP++;
3461 }
3462 lineInP += rasterP->scanlineStride;
3463 }
3464 }
3465
3466 (*env)->ReleasePrimitiveArrayCritical(env, jInDataP, inDataP, JNI_ABORT2);
3467
3468 return 0;
3469}
3470
3471/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
3472static int setPackedBCR(JNIEnv *env, RasterS_t *rasterP, int component,
3473 unsigned char *inDataP)
3474{
3475 int x, y, c;
3476 unsigned char *inP = inDataP;
3477 unsigned char *lineOutP, *outP;
3478 jarray jOutDataP;
3479 jsize dataArrayLength;
3480 unsigned char *outDataP;
3481 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3482
3483 if (rasterP->numBands > MAX_NUMBANDS32) {
3484 return -1;
3485 }
3486
3487 /* Grab data ptr, strides, offsets from raster */
3488 jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
3489 if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
3490 return -1;
3491 }
3492
3493 dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
3494 CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
offset; if (!((((1)) > 0) && ((rasterP->width)
>= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
3495
3496 outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
3497 if (outDataP == NULL((void*)0)) {
3498 return -1;
3499 }
3500 lineOutP = outDataP + rasterP->chanOffsets[0];
3501
3502 if (component < 0) {
3503 for (c=0; c < rasterP->numBands; c++) {
3504 loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3505 if (loff[c] < 0) {
3506 roff[c] = -loff[c];
3507 loff[c] = 0;
3508 }
3509 else roff[c] = 0;
3510 }
3511 /* Convert the all bands */
3512 for (y=0; y < rasterP->height; y++) {
3513 outP = lineOutP;
3514 *outP = 0;
3515 for (x=0; x < rasterP->width; x++) {
3516 for (c=0; c < rasterP->numBands; c++, inP++) {
3517 *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
3518 }
3519 outP++;
3520 }
3521 lineOutP += rasterP->scanlineStride;
3522 }
3523 }
3524 else {
3525 c = component;
3526 loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3527 if (loff[0] < 0) {
3528 roff[0] = -loff[0];
3529 loff[0] = 0;
3530 }
3531 else roff[c] = 0;
3532 for (y=0; y < rasterP->height; y++) {
3533 outP = lineOutP;
3534 for (x=0; x < rasterP->width; x++, inP++) {
3535 *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
3536 outP++;
3537 }
3538 lineOutP += rasterP->scanlineStride;
3539 }
3540 }
3541
3542 (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);
3543
3544 return 0;
3545}
3546
3547/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3548static int setPackedSCR(JNIEnv *env, RasterS_t *rasterP, int component,
3549 unsigned char *inDataP)
3550{
3551 int x, y, c;
3552 unsigned char *inP = inDataP;
3553 unsigned short *lineOutP, *outP;
3554 jarray jOutDataP;
3555 jsize dataArrayLength;
3556 unsigned short *outDataP;
3557 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3558
3559 if (rasterP->numBands > MAX_NUMBANDS32) {
3560 return -1;
3561 }
3562
3563 /* Grab data ptr, strides, offsets from raster */
3564 jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
3565 if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
3566 return -1;
3567 }
3568
3569 dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
3570 CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
offset; if (!((((1)) > 0) && ((rasterP->width)
>= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
3571
3572 outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
3573 if (outDataP == NULL((void*)0)) {
3574 return -1;
3575 }
3576 lineOutP = outDataP + rasterP->chanOffsets[0];
3577
3578 if (component < 0) {
3579 for (c=0; c < rasterP->numBands; c++) {
3580 loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3581 if (loff[c] < 0) {
3582 roff[c] = -loff[c];
3583 loff[c] = 0;
3584 }
3585 else roff[c] = 0;
3586 }
3587 /* Convert the all bands */
3588 for (y=0; y < rasterP->height; y++) {
3589 outP = lineOutP;
3590 for (x=0; x < rasterP->width; x++) {
3591 for (c=0; c < rasterP->numBands; c++, inP++) {
3592 /* Not correct. Might need to unpremult, shift, etc */
3593 *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
3594 }
3595 outP++;
3596 }
3597 lineOutP += rasterP->scanlineStride;
3598 }
3599 }
3600 else {
3601 c = component;
3602 loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3603 if (loff[0] < 0) {
3604 roff[0] = -loff[0];
3605 loff[0] = 0;
3606 }
3607 else roff[c] = 0;
3608 for (y=0; y < rasterP->height; y++) {
3609 outP = lineOutP;
3610 for (x=0; x < rasterP->width; x++, inP++) {
3611 *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
3612 outP++;
3613 }
3614 lineOutP += rasterP->scanlineStride;
3615 }
3616 }
3617
3618 (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);
3619
3620 return 0;
3621}
3622
3623/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3624static int setPackedICR(JNIEnv *env, RasterS_t *rasterP, int component,
3625 unsigned char *inDataP)
3626{
3627 int x, y, c;
3628 unsigned char *inP = inDataP;
3629 unsigned int *lineOutP, *outP;
3630 jarray jOutDataP;
3631 jsize dataArrayLength;
3632 unsigned int *outDataP;
3633 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3634
3635 if (rasterP->numBands > MAX_NUMBANDS32) {
3636 return -1;
3637 }
3638
3639 /* Grab data ptr, strides, offsets from raster */
3640 jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
3641 if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
3642 return -1;
3643 }
3644
3645 dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
3646 CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
offset; if (!((((1)) > 0) && ((rasterP->width)
>= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
3647
3648 outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
3649 if (outDataP == NULL((void*)0)) {
3650 return -1;
3651 }
3652 lineOutP = outDataP + rasterP->chanOffsets[0];
3653
3654 if (component < 0) {
3655 for (c=0; c < rasterP->numBands; c++) {
3656 loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3657 if (loff[c] < 0) {
3658 roff[c] = -loff[c];
3659 loff[c] = 0;
3660 }
3661 else roff[c] = 0;
3662 }
3663 /* Convert the all bands */
3664 for (y=0; y < rasterP->height; y++) {
3665 outP = lineOutP;
3666 for (x=0; x < rasterP->width; x++) {
3667 for (c=0; c < rasterP->numBands; c++, inP++) {
3668 /* Not correct. Might need to unpremult, shift, etc */
3669 *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
3670 }
3671 outP++;
3672 }
3673 lineOutP += rasterP->scanlineStride;
3674 }
3675 }
3676 else {
3677 c = component;
3678 loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3679 if (loff[0] < 0) {
3680 roff[0] = -loff[0];
3681 loff[0] = 0;
3682 }
3683 else roff[c] = 0;
3684
3685 for (y=0; y < rasterP->height; y++) {
3686 outP = lineOutP;
3687 for (x=0; x < rasterP->width; x++, inP++) {
3688 *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
3689 outP++;
3690 }
3691 lineOutP += rasterP->scanlineStride;
3692 }
3693 }
3694
3695 (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);
3696
3697 return 0;
3698}
3699
3700/* This routine is expecting a ByteComponentRaster with a PackedColorModel */
3701static int setPackedBCRdefault(JNIEnv *env, RasterS_t *rasterP,
3702 int component, unsigned char *inDataP,
3703 int supportsAlpha)
3704{
3705 int x, y, c;
3706 unsigned char *inP = inDataP;
3707 unsigned char *lineOutP, *outP;
3708 jarray jOutDataP;
3709 jsize dataArrayLength;
3710 unsigned char *outDataP;
3711 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3712 int a = rasterP->numBands - 1;
3713
3714 if (rasterP->numBands > MAX_NUMBANDS32) {
3715 return -1;
3716 }
3717
3718 /* Grab data ptr, strides, offsets from raster */
3719 jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_BCRdataID);
3720 if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
3721 return -1;
3722 }
3723
3724 dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
3725 CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
offset; if (!((((1)) > 0) && ((rasterP->width)
>= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
3726
3727 outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
3728 if (outDataP == NULL((void*)0)) {
3729 return -1;
3730 }
3731 lineOutP = outDataP + rasterP->chanOffsets[0];
3732
3733 if (component < 0) {
3734 for (c=0; c < rasterP->numBands; c++) {
3735 loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3736 if (loff[c] < 0) {
3737 roff[c] = -loff[c];
3738 loff[c] = 0;
3739 }
3740 else roff[c] = 0;
3741 }
3742 /* Convert the all bands */
3743 if (supportsAlpha) {
3744 for (y=0; y < rasterP->height; y++) {
3745 outP = lineOutP;
3746 *outP = 0;
3747 for (x=0; x < rasterP->width; x++) {
3748 *outP |= (*inP<<loff[a]>>roff[a])&
3749 rasterP->sppsm.maskArray[a];
3750 inP++;
3751 for (c=0; c < rasterP->numBands-1; c++, inP++) {
3752 *outP |= (*inP<<loff[c]>>roff[c])&
3753 rasterP->sppsm.maskArray[c];
3754 }
3755 outP++;
3756 }
3757 lineOutP += rasterP->scanlineStride;
3758 }
3759 }
3760 else {
3761 for (y=0; y < rasterP->height; y++) {
3762 outP = lineOutP;
3763 *outP = 0;
3764 for (x=0; x < rasterP->width; x++) {
3765 inP++;
3766 for (c=0; c < rasterP->numBands; c++, inP++) {
3767 *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
3768 }
3769 outP++;
3770 }
3771 lineOutP += rasterP->scanlineStride;
3772 }
3773 }
3774 }
3775 else {
3776 c = component;
3777 loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3778 if (loff[0] < 0) {
3779 roff[0] = -loff[0];
3780 loff[0] = 0;
3781 }
3782 else roff[c] = 0;
3783 for (y=0; y < rasterP->height; y++) {
3784 outP = lineOutP;
3785 for (x=0; x < rasterP->width; x++, inP++) {
3786 *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
3787 outP++;
3788 }
3789 lineOutP += rasterP->scanlineStride;
3790 }
3791 }
3792
3793 (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);
3794
3795 return 0;
3796}
3797
3798/* This routine is expecting a ShortComponentRaster with a PackedColorModel */
3799static int setPackedSCRdefault(JNIEnv *env, RasterS_t *rasterP,
3800 int component, unsigned char *inDataP,
3801 int supportsAlpha)
3802{
3803 int x, y, c;
3804 unsigned char *inP = inDataP;
3805 unsigned short *lineOutP, *outP;
3806 jarray jOutDataP;
3807 jsize dataArrayLength;
3808 unsigned short *outDataP;
3809 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3810 int a = rasterP->numBands - 1;
3811
3812 if (rasterP->numBands > MAX_NUMBANDS32) {
3813 return -1;
3814 }
3815
3816 /* Grab data ptr, strides, offsets from raster */
3817 jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_SCRdataID);
3818 if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
3819 return -1;
3820 }
3821 dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
3822 CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
offset; if (!((((1)) > 0) && ((rasterP->width)
>= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
3823
3824 outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
3825 if (outDataP == NULL((void*)0)) {
3826 return -1;
3827 }
3828 lineOutP = outDataP + rasterP->chanOffsets[0];
3829
3830 if (component < 0) {
3831 for (c=0; c < rasterP->numBands; c++) {
3832 loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3833 if (loff[c] < 0) {
3834 roff[c] = -loff[c];
3835 loff[c] = 0;
3836 }
3837 else roff[c] = 0;
3838 }
3839 /* Convert the all bands */
3840 if (supportsAlpha) {
3841 for (y=0; y < rasterP->height; y++) {
3842 outP = lineOutP;
3843 for (x=0; x < rasterP->width; x++) {
3844 *outP |= (*inP<<loff[a]>>roff[a])&
3845 rasterP->sppsm.maskArray[a];
3846 inP++;
3847 for (c=0; c < rasterP->numBands-1; c++, inP++) {
3848 /* Not correct. Might need to unpremult, shift, etc */
3849 *outP |= (*inP<<loff[c]>>roff[c])&
3850 rasterP->sppsm.maskArray[c];
3851 }
3852 outP++;
3853 }
3854 lineOutP += rasterP->scanlineStride;
3855 }
3856 }
3857 else {
3858 for (y=0; y < rasterP->height; y++) {
3859 outP = lineOutP;
3860 for (x=0; x < rasterP->width; x++) {
3861 inP++;
3862 for (c=0; c < rasterP->numBands; c++, inP++) {
3863 /* Not correct. Might need to unpremult, shift, etc */
3864 *outP |= (*inP<<loff[c]>>roff[c])&rasterP->sppsm.maskArray[c];
3865 }
3866 outP++;
3867 }
3868 lineOutP += rasterP->scanlineStride;
3869 }
3870 }
3871 }
3872 else {
3873 c = component;
3874 loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3875 if (loff[0] < 0) {
3876 roff[0] = -loff[0];
3877 loff[0] = 0;
3878 }
3879 else roff[c] = 0;
3880 for (y=0; y < rasterP->height; y++) {
3881 outP = lineOutP;
3882 for (x=0; x < rasterP->width; x++, inP++) {
3883 *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
3884 outP++;
3885 }
3886 lineOutP += rasterP->scanlineStride;
3887 }
3888 }
3889
3890 (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);
3891
3892 return 0;
3893}
3894
3895/* This routine is expecting a IntegerComponentRaster with a PackedColorModel*/
3896static int setPackedICRdefault(JNIEnv *env, RasterS_t *rasterP,
3897 int component, unsigned char *inDataP,
3898 int supportsAlpha)
3899{
3900 int x, y, c;
3901 unsigned char *inP = inDataP;
3902 unsigned int *lineOutP, *outP;
3903 jarray jOutDataP;
3904 jsize dataArrayLength;
3905 unsigned int *outDataP;
3906 int loff[MAX_NUMBANDS32], roff[MAX_NUMBANDS32];
3907 int a = rasterP->numBands - 1;
3908
3909 if (rasterP->numBands > MAX_NUMBANDS32) {
3910 return -1;
3911 }
3912
3913 /* Grab data ptr, strides, offsets from raster */
3914 jOutDataP = (*env)->GetObjectField(env, rasterP->jraster, g_ICRdataID);
3915 if (JNU_IsNull(env, jOutDataP)((jOutDataP) == ((void*)0))) {
3916 return -1;
3917 }
3918
3919 dataArrayLength = (*env)->GetArrayLength(env, jOutDataP);
3920 CHECK_DST_ARRAY(rasterP->chanOffsets[0], rasterP->scanlineStride, 1)do { int offset = (rasterP->chanOffsets[0]); int lastScanOffset
; if (!((((rasterP->scanlineStride)) > 0) && ((
(rasterP->height - 1)) >= 0) && ((0x7fffffff / (
(rasterP->scanlineStride))) > ((rasterP->height - 1)
)))) { return (-2); } lastScanOffset = (rasterP->scanlineStride
) * (rasterP->height - 1); if (!(((offset) >= 0) &&
((lastScanOffset) >= 0) && ((0x7fffffff - (offset
)) > (lastScanOffset)))) { return (-2); } lastScanOffset +=
offset; if (!((((1)) > 0) && ((rasterP->width)
>= 0) && ((0x7fffffff / ((1))) > (rasterP->
width)))) { return (-2); } offset = (1) * rasterP->width; if
(!(((offset) >= 0) && ((lastScanOffset) >= 0) &&
((0x7fffffff - (offset)) > (lastScanOffset)))) { return (
-2); } lastScanOffset += offset; if (dataArrayLength < lastScanOffset
) { return (-2); } } while(0);;
3921
3922 outDataP = (*env)->GetPrimitiveArrayCritical(env, jOutDataP, 0);
3923 if (outDataP == NULL((void*)0)) {
3924 return -1;
3925 }
3926 lineOutP = outDataP + rasterP->chanOffsets[0];
3927
3928 if (component < 0) {
3929 for (c=0; c < rasterP->numBands; c++) {
3930 loff[c] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3931 if (loff[c] < 0) {
3932 roff[c] = -loff[c];
3933 loff[c] = 0;
3934 }
3935 else roff[c] = 0;
3936 }
3937 /* Convert the all bands */
3938 if (supportsAlpha) {
3939 for (y=0; y < rasterP->height; y++) {
3940 outP = lineOutP;
3941 for (x=0; x < rasterP->width; x++) {
3942 *outP |= (*inP<<loff[a]>>roff[a])&
3943 rasterP->sppsm.maskArray[a];
3944 inP++;
3945 for (c=0; c < rasterP->numBands-1; c++, inP++) {
3946 /* Not correct. Might need to unpremult, shift, etc */
3947 *outP |= (*inP<<loff[c]>>roff[c])&
3948 rasterP->sppsm.maskArray[c];
3949 }
3950 outP++;
3951 }
3952 lineOutP += rasterP->scanlineStride;
3953 }
3954 }
3955 else {
3956 for (y=0; y < rasterP->height; y++) {
3957 outP = lineOutP;
3958 for (x=0; x < rasterP->width; x++) {
3959 inP++;
3960 for (c=0; c < rasterP->numBands; c++, inP++) {
3961 /* Not correct. Might need to unpremult, shift, etc */
3962 *outP |= (*inP<<loff[c]>>roff[c])&
3963 rasterP->sppsm.maskArray[c];
3964 }
3965 outP++;
3966 }
3967 lineOutP += rasterP->scanlineStride;
3968 }
3969 }
3970 }
3971 else {
3972 c = component;
3973 loff[0] = rasterP->sppsm.offsets[c] + (rasterP->sppsm.nBits[c]-8);
3974 if (loff[0] < 0) {
3975 roff[0] = -loff[0];
3976 loff[0] = 0;
3977 }
3978 else roff[c] = 0;
3979
3980 for (y=0; y < rasterP->height; y++) {
3981 outP = lineOutP;
3982 for (x=0; x < rasterP->width; x++, inP++) {
3983 *outP |= (*inP<<loff[0]>>roff[0])&rasterP->sppsm.maskArray[c];
3984 outP++;
3985 }
3986 lineOutP += rasterP->scanlineStride;
3987 }
3988 }
3989
3990 (*env)->ReleasePrimitiveArrayCritical(env, jOutDataP, outDataP, JNI_ABORT2);
3991
3992 return 0;
3993}
3994
3995/* This is temporary code. Should go away when there is better color
3996 * conversion code available.
3997 * REMIND: Ignoring alpha
3998 */
3999/* returns the absolute value x */
4000#define ABS(x)((x) < 0 ? -(x) : (x)) ((x) < 0 ? -(x) : (x))
4001#define CLIP(val,min,max)((val < min) ? min : ((val > max) ? max : val)) ((val < min) ? min : ((val > max) ? max : val))
4002
4003static int
4004colorMatch(int r, int g, int b, int a, unsigned char *argb, int numColors) {
4005 int besti = 0;
4006 int mindist, i, t, d;
4007 unsigned char red, green, blue;
4008
4009 r = CLIP(r, 0, 255)((r < 0) ? 0 : ((r > 255) ? 255 : r));
4010 g = CLIP(g, 0, 255)((g < 0) ? 0 : ((g > 255) ? 255 : g));
4011 b = CLIP(b, 0, 255)((b < 0) ? 0 : ((b > 255) ? 255 : b));
4012
4013 /* look for pure gray match */
4014 if ((r == g) && (g == b)) {
4015 mindist = 256;
4016 for (i = 0 ; i < numColors ; i++, argb+=4) {
4017 red = argb[1];
4018 green = argb[2];
4019 blue = argb[3];
4020 if (! ((red == green) && (green == blue)) ) {
4021 continue;
4022 }
4023 d = ABS(red - r)((red - r) < 0 ? -(red - r) : (red - r));
4024 if (d == 0)
4025 return i;
4026 if (d < mindist) {
4027 besti = i;
4028 mindist = d;
4029 }
4030 }
4031 return besti;
4032 }
4033
4034 /* look for non-pure gray match */
4035 mindist = 256 * 256 * 256;
4036 for (i = 0 ; i < numColors ; i++, argb+=4) {
4037 red = argb[1];
4038 green = argb[2];
4039 blue = argb[3];
4040 t = red - r;
4041 d = t * t;
4042 if (d >= mindist) {
4043 continue;
4044 }
4045 t = green - g;
4046 d += t * t;
4047 if (d >= mindist) {
4048 continue;
4049 }
4050 t = blue - b;
4051 d += t * t;
4052 if (d >= mindist) {
4053 continue;
4054 }
4055 if (d == 0)
4056 return i;
4057 if (d < mindist) {
4058 besti = i;
4059 mindist = d;
4060 }
4061 }
4062
4063 return besti;
4064}