/*
* Class: sun_java2d_windows_GDIRenderer
* Method: doFillPoly
* Signature: (Lsun/java2d/windows/GDIWindowSurfaceData;Lsun/java2d/pipe/Region;Ljava/awt/Composite;III[I[II)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_windows_GDIRenderer_doFillPoly
(JNIEnv *env, jobject wr,
jobject sData,
jobject clip, jobject comp, jint color,
jint transx, jint transy,
jintArray xpointsarray, jintArray ypointsarray,
jint npoints)
{
J2dTraceLn(J2D_TRACE_INFO, "GDIRenderer_doFillPoly");
J2dTraceLn4(J2D_TRACE_VERBOSE,
" color=0x%x transx=%-4d transy=%-4d npoints=%-4d",
color, transx, transy, npoints);
if (JNU_IsNull(env, xpointsarray) || JNU_IsNull(env, ypointsarray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if (env->GetArrayLength(xpointsarray) < npoints ||
env->GetArrayLength(ypointsarray) < npoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array");
return;
}
if (npoints < 3) {
// Fix for 4067534 - assertion failure in 1.3.1 for degenerate polys
// Not enough points for a triangle.
// Note that this would be ignored later anyway, but returning
// here saves us from mistakes in TransformPoly and seeing bad
// return values from the Windows Polyline function.
return;
}
GDIWinSDOps *wsdo = GDIWindowSurfaceData_GetOps(env, sData);
if (wsdo == NULL) {
return;
}
POINT tmpPts[POLYTEMPSIZE], *pPoints;
jint *xpoints = (jint *) env->GetPrimitiveArrayCritical(xpointsarray, NULL);
jint *ypoints = (jint *) env->GetPrimitiveArrayCritical(ypointsarray, NULL);
pPoints = TransformPoly(xpoints, ypoints, transx, transy,
tmpPts, &npoints, FALSE, FALSE);
env->ReleasePrimitiveArrayCritical(xpointsarray, xpoints, JNI_ABORT);
env->ReleasePrimitiveArrayCritical(ypointsarray, ypoints, JNI_ABORT);
if (pPoints == NULL) {
return;
}
HDC hdc = wsdo->GetDC(env, wsdo, BRUSHONLY, NULL, clip, comp, color);
if (hdc == NULL) {
return;
}
::SetPolyFillMode(hdc, ALTERNATE);
::Polygon(hdc, pPoints, npoints);
wsdo->ReleaseDC(env, wsdo, hdc);
if (pPoints != tmpPts) {
free(pPoints);
}
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XDrawPoly
* Signature: (IJII[I[IIZ)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XDrawPoly
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint transx, jint transy,
jintArray xcoordsArray, jintArray ycoordsArray, jint npoints,
jboolean isclosed)
{
#ifndef HEADLESS
XPoint pTmp[POLYTEMPSIZE], *points;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, xcoordsArray) || JNU_IsNull(env, ycoordsArray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if ((*env)->GetArrayLength(env, ycoordsArray) < npoints ||
(*env)->GetArrayLength(env, xcoordsArray) < npoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array");
return;
}
if (npoints < 2) {
return;
}
points = transformPoints(env, xcoordsArray, ycoordsArray, transx, transy,
pTmp, (int *)&npoints, isclosed);
if (points == 0) {
JNU_ThrowOutOfMemoryError(env, "translated coordinate array");
} else {
if (npoints == 2) {
/*
* Some X11 implementations fail to draw anything for
* simple 2 point polygons where the vertices are the
* same point even though this violates the X11
* specification. For simplicity we will dispatch all
* 2 point polygons through XDrawLine even if they are
* non-degenerate as this may invoke less processing
* down the line than a Poly primitive anyway.
*/
XDrawLine(awt_display, xsdo->drawable, (GC) xgc,
points[0].x, points[0].y,
points[1].x, points[1].y);
} else {
XDrawLines(awt_display, xsdo->drawable, (GC) xgc,
points, npoints, CoordModeOrigin);
}
if (points != pTmp) {
free(points);
}
X11SD_DirectRenderNotify(env, xsdo);
}
#endif /* !HEADLESS */
}
jobject makeGlobal(
JNIEnv* env,
jobject l_obj
){
if(!JNU_IsNull(env, l_obj)) {
jobject g_obj = env->NewGlobalRef(l_obj);
env->DeleteLocalRef(l_obj);
if (JNU_IsNull(env, g_obj)) {
JNU_ThrowOutOfMemoryError(env, "");
} else {
return g_obj;
}
}
return NULL;
}
/*
* Class: sun_awt_DefaultMouseInfoPeer
* Method: isWindowUnderMouse
* Signature: (Ljava/awt/Window)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_DefaultMouseInfoPeer_isWindowUnderMouse
(JNIEnv * env, jclass cls, jobject window)
{
Window rootWindow, childWindow;
int i;
int32_t xr, yr, xw, yw;
uint32_t keys;
BOOL pointerFound;
struct FrameData *wdata;
jobject winPeer;
if ((*env)->EnsureLocalCapacity(env, 1) < 0) {
return JNI_FALSE;
}
winPeer = (*env)->GetObjectField(env, window, componentIDs.peer);
if (JNU_IsNull(env, winPeer)) {
return JNI_FALSE;
}
wdata = (struct FrameData *)
JNU_GetLongFieldAsPtr(env, winPeer, mComponentPeerIDs.pData);
(*env)->DeleteLocalRef(env, winPeer);
if (wdata == NULL) {
return JNI_FALSE;
}
AWT_LOCK();
pointerFound = XQueryPointer(awt_display, XtWindow(wdata->winData.shell),
&rootWindow, &childWindow,
&xr, &yr, &xw, &yw, &keys);
AWT_UNLOCK();
return pointerFound ? JNI_TRUE : JNI_FALSE;
}
int TestSetClip(JNIEnv *env, D3DContext *d3dContext,
DDrawSurface *lpPlainSurface)
{
int testRes = J2D_D3D_FAILURE;
if (SUCCEEDED(d3dContext->SetRenderTarget(lpPlainSurface))) {
jobject clip =
JNU_CallStaticMethodByName(env, NULL,
"sun/java2d/pipe/Region",
"getInstanceXYWH",
"(IIII)Lsun/java2d/pipe/Region;",
0, 0, D3D_TEST_RASTER_W, D3D_TEST_RASTER_H).l;
if (!JNU_IsNull(env, clip)) {
if (SUCCEEDED(d3dContext->SetClip(env, clip, JNI_TRUE,
0, 0,
D3D_TEST_RASTER_W,
D3D_TEST_RASTER_H)))
{
testRes |= J2D_D3D_DEPTH_SURFACE_OK;
}
env->DeleteLocalRef(clip);
}
}
return testRes;
}
void releaseGlobal(
JNIEnv* env,
jobject g_obj
){
if(!JNU_IsNull(env, g_obj)) {
env->DeleteGlobalRef(g_obj);
}
}
JNIEXPORT int32_t JNICALL
awt_GetColor(JAWT_DrawingSurface* ds, int32_t r, int32_t g, int32_t b)
{
JNIEnv* env;
jobject target, peer;
jclass componentClass;
AwtGraphicsConfigDataPtr adata;
int32_t result;
jobject gc_object;
if (ds == NULL) {
#ifdef DEBUG
fprintf(stderr, "Drawing Surface is NULL\n");
#endif
return (int32_t) 0;
}
env = ds->env;
target = ds->target;
/* Make sure the target is a java.awt.Component */
componentClass = (*env)->FindClass(env, "java/awt/Component");
if (!(*env)->IsInstanceOf(env, target, componentClass)) {
#ifdef DEBUG
fprintf(stderr, "DrawingSurface target must be a component\n");
#endif
return (int32_t) 0;
}
if (!awtLockInited) {
return (int32_t) 0;
}
AWT_LOCK();
/* Get the peer of the target component */
peer = (*env)->GetObjectField(env, target, componentIDs.peer);
if (JNU_IsNull(env, peer)) {
#ifdef DEBUG
fprintf(stderr, "Component peer is NULL\n");
#endif
AWT_UNLOCK();
return (int32_t) 0;
}
/* GraphicsConfiguration object of MComponentPeer */
gc_object = (*env)->GetObjectField(env, peer, graphicsConfigID);
if (gc_object != NULL) {
adata = (AwtGraphicsConfigDataPtr)
JNU_GetLongFieldAsPtr(env, gc_object,
x11GraphicsConfigIDs.aData);
} else {
adata = getDefaultConfig(DefaultScreen(awt_display));
}
result = adata->AwtColorMatch(r, g, b, adata);
AWT_UNLOCK();
return result;
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillPoly
* Signature: (IJII[I[II)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillPoly
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jint transx, jint transy,
jintArray xcoordsArray, jintArray ycoordsArray, jint npoints)
{
#ifndef HEADLESS
XPoint pTmp[POLYTEMPSIZE], *points;
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, xcoordsArray) || JNU_IsNull(env, ycoordsArray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if ((*env)->GetArrayLength(env, ycoordsArray) < npoints ||
(*env)->GetArrayLength(env, xcoordsArray) < npoints)
{
JNU_ThrowArrayIndexOutOfBoundsException(env, "coordinate array");
return;
}
if (npoints < 3) {
return;
}
points = transformPoints(env, xcoordsArray, ycoordsArray, transx, transy,
pTmp, (int *)&npoints, JNI_FALSE);
if (points == 0) {
JNU_ThrowOutOfMemoryError(env, "translated coordinate array");
} else {
if (npoints > 2) {
XFillPolygon(awt_display, xsdo->drawable, (GC) xgc,
points, npoints, Complex, CoordModeOrigin);
X11SD_DirectRenderNotify(env, xsdo);
}
if (points != pTmp) {
free(points);
}
}
#endif /* !HEADLESS */
}
/**
* Native method of WBufferStrategy.java. Given a Component
* object, this method will find the back buffer associated
* with the Component's BufferStrategy and return a handle
* to it.
*/
extern "C" JNIEXPORT jobject JNICALL
Java_sun_awt_windows_WBufferStrategy_getDrawBuffer(JNIEnv *env, jclass wbs,
jobject component)
{
if (!JNU_IsNull(env, getBackBufferID)) {
return env->CallObjectMethod(component, getBackBufferID);
} else {
return NULL;
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: SetProperty
* Signature: (JJJLjava/lang/String;)V
*/
JNIEXPORT void JNICALL Java_sun_awt_X11_XlibWrapper_SetProperty
(JNIEnv *env, jclass clazz, jlong display, jlong window, jlong atom, jstring jstr) {
char *cname;
XTextProperty tp;
int32_t status;
/*
In case there are direct support of UTF-8 declared, use UTF-8 strings.
*/
if (!JNU_IsNull(env, jstr)) {
#ifdef X_HAVE_UTF8_STRING
cname = (*env)->GetStringUTFChars(env, jstr, JNI_FALSE);
#else
cname = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
#endif
} else {
cname = "";
}
#ifdef X_HAVE_UTF8_STRING
status = Xutf8TextListToTextProperty((Display *)display, &cname, 1,
XStdICCTextStyle, &tp);
#else
status = XmbTextListToTextProperty((Display *)display, &cname, 1,
XStdICCTextStyle, &tp);
#endif
if (status == Success || status > 0) {
AWT_CHECK_HAVE_LOCK();
XChangeProperty((Display *)display, window, atom, tp.encoding, tp.format, PropModeReplace, tp.value, tp.nitems);
if (tp.value != NULL) {
XFree(tp.value);
}
}
if (!JNU_IsNull(env, jstr)) {
#ifdef X_HAVE_UTF8_STRING
(*env)->ReleaseStringUTFChars(env, jstr, (const char *) cname);
#else
JNU_ReleaseStringPlatformChars(env, jstr, (const char *) cname);
#endif
}
}
/*
* Lock the surface of the target component for native rendering.
* When finished drawing, the surface must be unlocked with
* Unlock(). This function returns a bitmask with one or more of the
* following values:
*
* JAWT_LOCK_ERROR - When an error has occurred and the surface could not
* be locked.
*
* JAWT_LOCK_CLIP_CHANGED - When the clip region has changed.
*
* JAWT_LOCK_BOUNDS_CHANGED - When the bounds of the surface have changed.
*
* JAWT_LOCK_SURFACE_CHANGED - When the surface itself has changed
*/
JNIEXPORT jint JNICALL awt_DrawingSurface_Lock(JAWT_DrawingSurface* ds)
{
JNIEnv* env;
jobject target, peer;
jclass componentClass;
jint drawState;
if (ds == NULL) {
#ifdef DEBUG
fprintf(stderr, "Drawing Surface is NULL\n");
#endif
return (jint)JAWT_LOCK_ERROR;
}
env = ds->env;
target = ds->target;
/* Make sure the target is a java.awt.Component */
componentClass = (*env)->FindClass(env, "java/awt/Component");
if (!(*env)->IsInstanceOf(env, target, componentClass)) {
#ifdef DEBUG
fprintf(stderr, "Target is not a component\n");
#endif
return (jint)JAWT_LOCK_ERROR;
}
if (!awtLockInited) {
return (jint)JAWT_LOCK_ERROR;
}
AWT_LOCK();
/* Get the peer of the target component */
peer = (*env)->GetObjectField(env, target, componentIDs.peer);
if (JNU_IsNull(env, peer)) {
#ifdef DEBUG
fprintf(stderr, "Component peer is NULL\n");
#endif
AWT_FLUSH_UNLOCK();
return (jint)JAWT_LOCK_ERROR;
}
#ifndef XAWT
drawState = (*env)->GetIntField(env, peer, mComponentPeerIDs.drawState);
(*env)->SetIntField(env, peer, mComponentPeerIDs.drawState, 0);
#else
drawState = (*env)->GetIntField(env, peer, drawStateID);
(*env)->SetIntField(env, peer, drawStateID, 0);
#endif
return drawState;
}
jobject
AwtDataTransferer::ConcatData(JNIEnv* env, jobject obj1, jobject obj2) {
jobject transferer = GetDataTransferer(env);
if (!JNU_IsNull(env, transferer)) {
jobject ret = NULL;
DECLARE_OBJECT_JAVA_METHOD(concatDataMethodID, dataTransfererClazz,
"concatData",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
ret = env->CallObjectMethod(transferer, concatDataMethodID, obj1, obj2);
if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {
env->ExceptionDescribe();
env->ExceptionClear();
}
env->DeleteLocalRef(transferer);
return ret;
} else {
return NULL;
}
}
/*
* Find a class for the given class name and return a global reference to the
* class.
*/
static jobject
findClass(const char *className)
{
JNIEnv *env = (JNIEnv *)JNU_GetEnv(jvm, JNI_VERSION_1_2);
jclass classClass;
jobject objectClass;
classClass = (*env)->FindClass(env, className);
objectClass = (*env)->NewGlobalRef(env,classClass);
if (JNU_IsNull(env, objectClass)) {
JNU_ThrowClassNotFoundException(env, className);
}
return objectClass;
}
JNIEXPORT void JNICALL
Java_java_awt_AWTEvent_nativeSetSource(JNIEnv *env, jobject self,
jobject newSource)
{
jbyteArray bdata;
AWT_LOCK();
bdata = (jbyteArray)(*env)->GetObjectField(env, self, awtEventIDs.bdata);
if (bdata != NULL) {
XEvent *xev;
Window w;
jboolean dummy;
/* get the widget out of the peer newSource */
struct ComponentData *cdata = (struct ComponentData *)
JNU_GetLongFieldAsPtr(env, newSource, mComponentPeerIDs.pData);
if (JNU_IsNull(env, cdata) || (cdata == NULL) ||
((cdata->widget != NULL) && (XtIsObject(cdata->widget)) &&
(cdata->widget->core.being_destroyed))) {
JNU_ThrowNullPointerException(env, "null widget");
AWT_UNLOCK();
return;
}
/* get the Window out of the widget */
w = XtWindow(cdata->widget);
if (w == None) {
JNU_ThrowNullPointerException(env, "null window");
AWT_UNLOCK();
return;
}
/* reset the filed in the event */
xev = (XEvent *)(*env)->GetPrimitiveArrayCritical(env, bdata, &dummy);
if (xev == NULL) {
JNU_ThrowNullPointerException(env, "null data");
AWT_UNLOCK();
return;
}
xev->xany.window = w;
(*env)->ReleasePrimitiveArrayCritical(env, bdata, (void *)xev, 0);
}
AWT_UNLOCK();
}
/*
* Class: sun_awt_DefaultMouseInfoPeer
* Method: isWindowUnderMouse
* Signature: (Ljava/awt/Window)Z
*/
JNIEXPORT jboolean JNICALL Java_sun_awt_DefaultMouseInfoPeer_isWindowUnderMouse
(JNIEnv * env, jclass cls, jobject window)
{
Window rootWindow = None, parentWindow = None, siblingWindow = None;
Window * children = NULL;
int i = 0;
int is_the_same_screen = 0;
int32_t xr = 0, yr = 0, xw = 0, yw = 0;
uint32_t keys = 0;
uint32_t nchildren = 0;
Bool pointerFound = 0;
struct FrameData *wdata = NULL;
jobject winPeer = NULL;
if ((*env)->EnsureLocalCapacity(env, 1) < 0) {
return JNI_FALSE;
}
winPeer = (*env)->GetObjectField(env, window, componentIDs.peer);
if (JNU_IsNull(env, winPeer)) {
return JNI_FALSE;
}
wdata = (struct FrameData *)
JNU_GetLongFieldAsPtr(env, winPeer, mComponentPeerIDs.pData);
(*env)->DeleteLocalRef(env, winPeer);
if (wdata == NULL) {
return JNI_FALSE;
}
AWT_LOCK();
XQueryTree(awt_display, XtWindow(wdata->winData.comp.widget),
&rootWindow, &parentWindow, &children, &nchildren);
is_the_same_screen = XQueryPointer(awt_display, parentWindow,
&rootWindow, &siblingWindow, &xr, &yr, &xw, &yw, &keys);
if (siblingWindow == XtWindow(wdata->winData.comp.widget) && is_the_same_screen) {
AWT_UNLOCK();
return JNI_TRUE;
}
AWT_UNLOCK();
return JNI_FALSE ;
}
/*
* Class: sun_awt_X11RemoteOffScreenImage
* Method: initIDs
* Signature: ()V
*/
JNIEXPORT void JNICALL
Java_sun_awt_motif_X11RemoteOffScreenImage_initIDs(JNIEnv *env, jclass bisd)
{
static char *bimgName = "java/awt/image/BufferedImage";
jclass bimg = (*env)->FindClass(env, bimgName);
if (JNU_IsNull(env, bimg)) {
JNU_ThrowClassNotFoundException(env, bimgName);
return;
}
sDataID = (*env)->GetFieldID(env, bimg, "sData", "Lsun/java2d/SurfaceData;");
if (sDataID == 0) {
JNU_ThrowInternalError(env, "Could not get field IDs");
}
rasterID = (*env)->GetFieldID(env, bimg, "raster", "Ljava/awt/image/WritableRaster;");
if (rasterID == 0) {
JNU_ThrowInternalError(env, "Could not get field IDs");
}
}
/*
* Class: sun_awt_X11_XlibWrapper
* Method: XSetLocaleModifiers
* Signature: (Ljava/lang/String;)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_sun_awt_X11_XlibWrapper_XSetLocaleModifiers
(JNIEnv *env, jclass clazz, jstring jstr)
{
char * modifier_list = NULL;
char * ret = NULL;
if (!JNU_IsNull(env, jstr)) {
modifier_list = (char *)JNU_GetStringPlatformChars(env, jstr, NULL);
}
AWT_CHECK_HAVE_LOCK();
if (modifier_list) {
ret = XSetLocaleModifiers(modifier_list);
JNU_ReleaseStringPlatformChars(env, jstr, (const char *) modifier_list);
} else {
ret = XSetLocaleModifiers("");
}
return (ret != NULL ? JNU_NewStringPlatform(env, ret): NULL);
}
/*
* Class: sun_java2d_x11_X11Renderer
* Method: XFillSpans
* Signature: (IJLsun/java2d/pipe/SpanIterator;JII)V
*/
JNIEXPORT void JNICALL Java_sun_java2d_x11_X11Renderer_XFillSpans
(JNIEnv *env, jobject xr,
jlong pXSData, jlong xgc,
jobject si, jlong pIterator,
jint transx, jint transy)
{
#ifndef HEADLESS
SpanIteratorFuncs *pFuncs = (SpanIteratorFuncs *) jlong_to_ptr(pIterator);
void *srData;
jint x, y, w, h;
jint spanbox[4];
X11SDOps *xsdo = (X11SDOps *) pXSData;
if (xsdo == NULL) {
return;
}
if (JNU_IsNull(env, si)) {
JNU_ThrowNullPointerException(env, "span iterator");
return;
}
if (pFuncs == NULL) {
JNU_ThrowNullPointerException(env, "native iterator not supplied");
return;
}
srData = (*pFuncs->open)(env, si);
while ((*pFuncs->nextSpan)(srData, spanbox)) {
x = spanbox[0] + transx;
y = spanbox[1] + transy;
w = spanbox[2] - spanbox[0];
h = spanbox[3] - spanbox[1];
XFillRectangle(awt_display, xsdo->drawable, (GC) xgc,
CLAMP_TO_SHORT(x), CLAMP_TO_SHORT(y),
CLAMP_TO_USHORT(w), CLAMP_TO_USHORT(h));
}
(*pFuncs->close)(env, srData);
X11SD_DirectRenderNotify(env, xsdo);
#endif /* !HEADLESS */
}
jint JAWTDrawingSurfaceInfo::Init(JAWTDrawingSurface* parent)
{
TRY;
JNIEnv* env = parent->env;
jobject target = parent->target;
if (JNU_IsNull(env, target)) {
DTRACE_PRINTLN("NULL target");
return JAWT_LOCK_ERROR;
}
HWND newHwnd = AwtComponent::GetHWnd(env, target);
if (!::IsWindow(newHwnd)) {
DTRACE_PRINTLN("Bad HWND");
return JAWT_LOCK_ERROR;
}
jint retval = 0;
platformInfo = this;
ds = parent;
bounds.x = env->GetIntField(target, AwtComponent::xID);
bounds.y = env->GetIntField(target, AwtComponent::yID);
bounds.width = env->GetIntField(target, AwtComponent::widthID);
bounds.height = env->GetIntField(target, AwtComponent::heightID);
if (hwnd != newHwnd) {
if (hwnd != NULL) {
::ReleaseDC(hwnd, hdc);
retval = JAWT_LOCK_SURFACE_CHANGED;
}
hwnd = newHwnd;
hdc = ::GetDCEx(hwnd, NULL, DCX_CACHE|DCX_CLIPCHILDREN|DCX_CLIPSIBLINGS);
}
clipSize = 1;
clip = &bounds;
int screen = AwtWin32GraphicsDevice::DeviceIndexForWindow(hwnd);
hpalette = AwtWin32GraphicsDevice::GetPalette(screen);
return retval;
CATCH_BAD_ALLOC_RET(JAWT_LOCK_ERROR);
}
static SurfaceDataOps *
GetSDOps(JNIEnv *env, jobject sData, jboolean callSetup)
{
SurfaceDataOps *ops;
if (JNU_IsNull(env, sData)) {
JNU_ThrowNullPointerException(env, "surfaceData");
return NULL;
}
ops = (SurfaceDataOps *)JNU_GetLongFieldAsPtr(env, sData, pDataID);
if (ops == NULL) {
if (!(*env)->ExceptionOccurred(env) &&
!(*env)->IsInstanceOf(env, sData, pNullSurfaceDataClass))
{
if (!(*env)->GetBooleanField(env, sData, validID)) {
SurfaceData_ThrowInvalidPipeException(env, "invalid data");
} else {
JNU_ThrowNullPointerException(env, "native ops missing");
}
}
} else if (callSetup) {
SurfaceData_InvokeSetup(env, ops);
}
return ops;
}
/* Parse the buffered image. All of the raster information is returned in the
* imagePP structure.
*
* The handleCustom parameter specifies whether or not the caller
* can use custom channels. If it is false and a custom channel
* is encountered, the returned value will be 0 and all structures
* will be deallocated.
*
* Return value:
* -1: Exception
* 0: Can't do it.
* 1: Success
*/
int awt_parseImage(JNIEnv *env, jobject jimage, BufImageS_t **imagePP,
int handleCustom) {
BufImageS_t *imageP;
int status;
jobject jraster;
jobject jcmodel;
/* Make sure the image exists */
if (JNU_IsNull(env, jimage)) {
JNU_ThrowNullPointerException(env, "null BufferedImage object");
return -1;
}
if ((imageP = (BufImageS_t *) calloc(1, sizeof(BufImageS_t))) == NULL) {
JNU_ThrowOutOfMemoryError(env, "Out of memory");
return -1;
}
imageP->jimage = jimage;
/* Retrieve the raster */
if ((jraster = (*env)->GetObjectField(env, jimage,
g_BImgRasterID)) == NULL) {
free((void *) imageP);
JNU_ThrowNullPointerException(env, "null Raster object");
return 0;
}
/* Retrieve the image type */
imageP->imageType = (*env)->GetIntField(env, jimage, g_BImgTypeID);
/* Parse the raster */
if ((status = awt_parseRaster(env, jraster, &imageP->raster)) <= 0) {
free((void *)imageP);
return status;
}
/* Retrieve the color model */
if ((jcmodel = (*env)->GetObjectField(env, jimage, g_BImgCMID)) == NULL) {
free((void *) imageP);
JNU_ThrowNullPointerException(env, "null Raster object");
return 0;
}
/* Parse the color model */
if ((status = awt_parseColorModel(env, jcmodel, imageP->imageType,
&imageP->cmodel)) <= 0) {
awt_freeParsedRaster(&imageP->raster, FALSE);
free((void *)imageP);
return 0;
}
/* Set hints */
if ((status = setHints(env, imageP)) <= 0) {
awt_freeParsedImage(imageP, TRUE);
return 0;
}
*imagePP = imageP;
return status;
}
int awt_parseColorModel (JNIEnv *env, jobject jcmodel, int imageType,
ColorModelS_t *cmP) {
/*jmethodID jID; */
jobject jnBits;
int i;
static jobject s_jdefCM = NULL;
if (JNU_IsNull(env, jcmodel)) {
JNU_ThrowNullPointerException(env, "null ColorModel object");
return -1;
}
cmP->jcmodel = jcmodel;
cmP->jcspace = (*env)->GetObjectField(env, jcmodel, g_CMcspaceID);
cmP->numComponents = (*env)->GetIntField(env, jcmodel,
g_CMnumComponentsID);
cmP->supportsAlpha = (*env)->GetBooleanField(env, jcmodel,
g_CMsuppAlphaID);
cmP->isAlphaPre = (*env)->GetBooleanField(env,jcmodel,
g_CMisAlphaPreID);
cmP->transparency = (*env)->GetIntField(env, jcmodel,
g_CMtransparencyID);
if (imageType == java_awt_image_BufferedImage_TYPE_INT_ARGB) {
cmP->isDefaultCM = TRUE;
cmP->isDefaultCompatCM = TRUE;
} else if (imageType == java_awt_image_BufferedImage_TYPE_INT_ARGB_PRE ||
imageType == java_awt_image_BufferedImage_TYPE_INT_RGB) {
cmP->isDefaultCompatCM = TRUE;
} else if (imageType == java_awt_image_BufferedImage_TYPE_INT_BGR ||
imageType == java_awt_image_BufferedImage_TYPE_4BYTE_ABGR ||
imageType == java_awt_image_BufferedImage_TYPE_4BYTE_ABGR_PRE){
cmP->isDefaultCompatCM = TRUE;
}
else {
/* Figure out if this is the default CM */
if (s_jdefCM == NULL) {
jobject defCM;
jclass jcm = (*env)->FindClass(env, "java/awt/image/ColorModel");
defCM = (*env)->CallStaticObjectMethod(env, jcm,
g_CMgetRGBdefaultMID, NULL);
s_jdefCM = (*env)->NewGlobalRef(env, defCM);
if (defCM == NULL || s_jdefCM == NULL) {
JNU_ThrowNullPointerException(env,
"Unable to find default CM");
return -1;
}
}
cmP->isDefaultCM = ((*env)->IsSameObject(env, s_jdefCM, jcmodel));
cmP->isDefaultCompatCM = cmP->isDefaultCM;
}
if (cmP->isDefaultCompatCM) {
cmP->cmType = DIRECT_CM_TYPE;
cmP->nBits = (jint *) malloc(sizeof(jint)*4);
cmP->nBits[0] = cmP->nBits[1] = cmP->nBits[2] = cmP->nBits[3] = 8;
cmP->maxNbits = 8;
cmP->is_sRGB = TRUE;
cmP->csType = java_awt_color_ColorSpace_TYPE_RGB;
return 1;
}
jnBits = (*env)->GetObjectField(env, jcmodel, g_CMnBitsID);
if (jnBits == NULL) {
JNU_ThrowNullPointerException(env, "null nBits structure in CModel");
return -1;
}
if ((cmP->nBits =
(jint *) malloc(cmP->numComponents*sizeof(jint))) == NULL){
JNU_ThrowOutOfMemoryError(env, "Out of memory");
return -1;
}
(*env)->GetIntArrayRegion(env, jnBits, 0, cmP->numComponents,
cmP->nBits);
cmP->maxNbits = 0;
for (i=0; i < cmP->numComponents; i++) {
if (cmP->maxNbits < cmP->nBits[i]) {
cmP->maxNbits = cmP->nBits[i];
}
}
cmP->is_sRGB = (*env)->GetBooleanField(env, cmP->jcmodel, g_CMis_sRGBID);
cmP->csType = (*env)->GetIntField(env, cmP->jcmodel, g_CMcsTypeID);
/* Find out what type of colol model */
if (imageType == java_awt_image_BufferedImage_TYPE_BYTE_INDEXED ||
(*env)->IsInstanceOf(env, jcmodel,
(*env)->FindClass(env, "java/awt/image/IndexColorModel")))
{
cmP->cmType = INDEX_CM_TYPE;
cmP->transIdx = (*env)->GetIntField(env, jcmodel, g_ICMtransIdxID);
cmP->mapSize = (*env)->GetIntField(env, jcmodel, g_ICMmapSizeID);
cmP->jrgb = (*env)->GetObjectField(env, jcmodel, g_ICMrgbID);
if (cmP->transIdx == -1) {
/* Need to find the transparent index */
int *rgb = (int *) (*env)->GetPrimitiveArrayCritical(env,
cmP->jrgb,
NULL);
if (rgb == NULL) {
return -1;
}
for (i=0; i < cmP->mapSize; i++) {
if ((rgb[i]&0xff000000) == 0) {
cmP->transIdx = i;
break;
}
}
(*env)->ReleasePrimitiveArrayCritical(env, cmP->jrgb, rgb,
JNI_ABORT);
if (cmP->transIdx == -1) {
/* Now what? No transparent pixel... */
cmP->transIdx = 0;
}
}
}
else if ((*env)->IsInstanceOf(env, jcmodel,
(*env)->FindClass(env, "java/awt/image/PackedColorModel")))
{
if ((*env)->IsInstanceOf(env, jcmodel,
(*env)->FindClass(env, "java/awt/image/DirectColorModel"))){
cmP->cmType = DIRECT_CM_TYPE;
}
else {
cmP->cmType = PACKED_CM_TYPE;
}
}
else if ((*env)->IsInstanceOf(env, jcmodel,
(*env)->FindClass(env, "java/awt/image/ComponentColorModel")))
{
cmP->cmType = COMPONENT_CM_TYPE;
}
else if ((*env)->IsInstanceOf(env, jcmodel,
(*env)->FindClass(env, "java/awt/image/PackedColorModel")))
{
cmP->cmType = PACKED_CM_TYPE;
}
else {
cmP->cmType = UNKNOWN_CM_TYPE;
}
return 1;
}
/* Parse the raster. All of the raster information is returned in the
* rasterP structure.
*
* Return value:
* -1: Exception
* 0: Can't do it (Custom channel)
* 1: Success
*/
int awt_parseRaster(JNIEnv *env, jobject jraster, RasterS_t *rasterP) {
jobject joffs = NULL;
/* int status;*/
int isDiscrete = TRUE;
if (JNU_IsNull(env, jraster)) {
JNU_ThrowNullPointerException(env, "null Raster object");
return -1;
}
rasterP->jraster = jraster;
rasterP->width = (*env)->GetIntField(env, jraster, g_RasterWidthID);
rasterP->height = (*env)->GetIntField(env, jraster, g_RasterHeightID);
rasterP->numDataElements = (*env)->GetIntField(env, jraster,
g_RasterNumDataElementsID);
rasterP->numBands = (*env)->GetIntField(env, jraster,
g_RasterNumBandsID);
rasterP->baseOriginX = (*env)->GetIntField(env, jraster,
g_RasterBaseOriginXID);
rasterP->baseOriginY = (*env)->GetIntField(env, jraster,
g_RasterBaseOriginYID);
rasterP->minX = (*env)->GetIntField(env, jraster, g_RasterMinXID);
rasterP->minY = (*env)->GetIntField(env, jraster, g_RasterMinYID);
rasterP->jsampleModel = (*env)->GetObjectField(env, jraster,
g_RasterSampleModelID);
if (JNU_IsNull(env, rasterP->jsampleModel)) {
JNU_ThrowNullPointerException(env, "null Raster object");
return -1;
}
if ((*env)->IsInstanceOf(env, rasterP->jsampleModel,
(*env)->FindClass(env,"java/awt/image/SinglePixelPackedSampleModel"))) {
jobject jmask, joffs, jnbits;
rasterP->sppsm.maxBitSize = (*env)->GetIntField(env,
rasterP->jsampleModel,
g_SPPSMmaxBitID);
jmask = (*env)->GetObjectField(env, rasterP->jsampleModel,
g_SPPSMmaskArrID);
joffs = (*env)->GetObjectField(env, rasterP->jsampleModel,
g_SPPSMmaskOffID);
jnbits = (*env)->GetObjectField(env, rasterP->jsampleModel,
g_SPPSMnBitsID);
if (jmask == NULL || joffs == NULL || jnbits == NULL) {
JNU_ThrowInternalError(env, "Can't grab SPPSM fields");
return -1;
}
(*env)->GetIntArrayRegion(env, jmask, 0,
rasterP->numBands, rasterP->sppsm.maskArray);
(*env)->GetIntArrayRegion(env, joffs, 0,
rasterP->numBands, rasterP->sppsm.offsets);
(*env)->GetIntArrayRegion(env, jnbits, 0,
rasterP->numBands, rasterP->sppsm.nBits);
}
rasterP->baseRasterWidth = (*env)->GetIntField(env, rasterP->jsampleModel,
g_SMWidthID);
rasterP->baseRasterHeight = (*env)->GetIntField(env,
rasterP->jsampleModel,
g_SMHeightID);
if ((*env)->IsInstanceOf(env, jraster,
(*env)->FindClass(env, "sun/awt/image/IntegerComponentRaster"))){
rasterP->jdata = (*env)->GetObjectField(env, jraster, g_ICRdataID);
rasterP->dataType = INT_DATA_TYPE;
rasterP->dataSize = 4;
rasterP->dataIsShared = TRUE;
rasterP->rasterType = COMPONENT_RASTER_TYPE;
rasterP->type = (*env)->GetIntField(env, jraster, g_ICRtypeID);
rasterP->scanlineStride = (*env)->GetIntField(env, jraster, g_ICRscanstrID);
rasterP->pixelStride = (*env)->GetIntField(env, jraster, g_ICRpixstrID);
joffs = (*env)->GetObjectField(env, jraster, g_ICRdataOffsetsID);
}
else if ((*env)->IsInstanceOf(env, jraster,
(*env)->FindClass(env, "sun/awt/image/ByteComponentRaster"))){
rasterP->jdata = (*env)->GetObjectField(env, jraster, g_BCRdataID);
rasterP->dataType = BYTE_DATA_TYPE;
rasterP->dataSize = 1;
rasterP->dataIsShared = TRUE;
rasterP->rasterType = COMPONENT_RASTER_TYPE;
rasterP->type = (*env)->GetIntField(env, jraster, g_BCRtypeID);
rasterP->scanlineStride = (*env)->GetIntField(env, jraster, g_BCRscanstrID);
rasterP->pixelStride = (*env)->GetIntField(env, jraster, g_BCRpixstrID);
joffs = (*env)->GetObjectField(env, jraster, g_BCRdataOffsetsID);
}
else if ((*env)->IsInstanceOf(env, jraster,
(*env)->FindClass(env, "sun/awt/image/ShortComponentRaster"))){
rasterP->jdata = (*env)->GetObjectField(env, jraster, g_SCRdataID);
rasterP->dataType = SHORT_DATA_TYPE;
rasterP->dataSize = 2;
rasterP->dataIsShared = TRUE;
rasterP->rasterType = COMPONENT_RASTER_TYPE;
rasterP->type = (*env)->GetIntField(env, jraster, g_SCRtypeID);
rasterP->scanlineStride = (*env)->GetIntField(env, jraster, g_SCRscanstrID);
rasterP->pixelStride = (*env)->GetIntField(env, jraster, g_SCRpixstrID);
joffs = (*env)->GetObjectField(env, jraster, g_SCRdataOffsetsID);
}
else if ((*env)->IsInstanceOf(env, jraster,
(*env)->FindClass(env, "sun/awt/image/BytePackedRaster"))){
rasterP->rasterType = PACKED_RASTER_TYPE;
rasterP->dataType = BYTE_DATA_TYPE;
rasterP->dataSize = 1;
rasterP->scanlineStride = (*env)->GetIntField(env, jraster, g_BPRscanstrID);
rasterP->pixelStride = (*env)->GetIntField(env, jraster, g_BPRpixstrID);
rasterP->jdata = (*env)->GetObjectField(env, jraster, g_BPRdataID);
rasterP->type = (*env)->GetIntField(env, jraster, g_BPRtypeID);
if ((rasterP->chanOffsets = (jint *) malloc(rasterP->numDataElements *
sizeof(jint))) == NULL) {
/* Out of memory */
JNU_ThrowOutOfMemoryError(env, "Out of memory");
return -1;
}
rasterP->chanOffsets[0] = (*env)->GetIntField(env, jraster, g_BPRdataBitOffsetID);
rasterP->dataType = BYTE_DATA_TYPE;
isDiscrete = FALSE;
}
else {
rasterP->type = sun_awt_image_IntegerComponentRaster_TYPE_CUSTOM;
rasterP->dataType = UNKNOWN_DATA_TYPE;
rasterP->rasterType = UNKNOWN_RASTER_TYPE;
rasterP->chanOffsets = NULL;
/* Custom raster */
return 0;
}
if (isDiscrete) {
if ((rasterP->chanOffsets =
(jint *) malloc(rasterP->numDataElements*
sizeof(jint))) == NULL) {
/* Out of memory */
JNU_ThrowOutOfMemoryError(env, "Out of memory");
return -1;
}
(*env)->GetIntArrayRegion(env, joffs, 0, rasterP->numDataElements,
rasterP->chanOffsets);
}
#if 0
fprintf(stderr,"---------------------\n");
fprintf(stderr,"Width : %d\n",rasterP->width);
fprintf(stderr,"Height : %d\n",rasterP->height);
fprintf(stderr,"X : %d\n",rasterP->x);
fprintf(stderr,"Y : %d\n",rasterP->y);
fprintf(stderr,"numC : %d\n",rasterP->numDataElements);
fprintf(stderr,"SS : %d\n",rasterP->scanlineStride);
fprintf(stderr,"PS : %d\n",rasterP->pixelStride);
fprintf(stderr,"CO : %d\n",rasterP->chanOffsets);
fprintf(stderr,"shared?: %d\n",rasterP->dataIsShared);
fprintf(stderr,"RasterT: %d\n",rasterP->rasterType);
fprintf(stderr,"DataT : %d\n",rasterP->dataType);
fprintf(stderr,"---------------------\n");
#endif
return 1;
}
/*
* This routine is used to draw ICM pixels into a default color model
*/
JNIEXPORT void JNICALL
Java_sun_awt_image_ImageRepresentation_setICMpixels(JNIEnv *env, jclass cls,
jint x, jint y, jint w,
jint h, jintArray jlut,
jbyteArray jpix, jint off,
jint scansize,
jobject jict)
{
unsigned char *srcData = NULL;
int *dstData;
int *dstP, *dstyP;
unsigned char *srcyP, *srcP;
int *srcLUT = NULL;
int yIdx, xIdx;
int sStride;
int *cOffs;
int pixelStride;
jobject joffs = NULL;
jobject jdata = NULL;
if (JNU_IsNull(env, jlut)) {
JNU_ThrowNullPointerException(env, "NullPointerException");
return;
}
if (JNU_IsNull(env, jpix)) {
JNU_ThrowNullPointerException(env, "NullPointerException");
return;
}
sStride = (*env)->GetIntField(env, jict, g_ICRscanstrID);
pixelStride = (*env)->GetIntField(env, jict, g_ICRpixstrID);
joffs = (*env)->GetObjectField(env, jict, g_ICRdataOffsetsID);
jdata = (*env)->GetObjectField(env, jict, g_ICRdataID);
srcLUT = (int *) (*env)->GetPrimitiveArrayCritical(env, jlut, NULL);
if (srcLUT == NULL) {
JNU_ThrowNullPointerException(env, "Null IndexColorModel LUT");
return;
}
srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix,
NULL);
if (srcData == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
JNU_ThrowNullPointerException(env, "Null data array");
return;
}
cOffs = (int *) (*env)->GetPrimitiveArrayCritical(env, joffs, NULL);
if (cOffs == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
JNU_ThrowNullPointerException(env, "Null channel offset array");
return;
}
dstData = (int *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL);
if (dstData == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, joffs, cOffs, JNI_ABORT);
JNU_ThrowNullPointerException(env, "Null tile data array");
return;
}
dstyP = dstData + cOffs[0] + y*sStride + x*pixelStride;
srcyP = srcData + off;
for (yIdx = 0; yIdx < h; yIdx++, srcyP += scansize, dstyP+=sStride) {
srcP = srcyP;
dstP = dstyP;
for (xIdx = 0; xIdx < w; xIdx++, dstP+=pixelStride) {
*dstP = srcLUT[*srcP++];
}
}
/* Release the locked arrays */
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, joffs, cOffs, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT);
}
JNIEXPORT jint JNICALL
Java_sun_awt_image_ImageRepresentation_setDiffICM(JNIEnv *env, jclass cls,
jint x, jint y, jint w,
jint h, jintArray jlut,
jint transIdx, jint numLut,
jobject jicm,
jbyteArray jpix, jint off,
jint scansize,
jobject jbct, jint chanOff)
{
unsigned int *srcLUT = NULL;
unsigned int *newLUT = NULL;
int sStride;
int pixelStride;
int mapSize;
jobject jdata = NULL;
jobject jnewlut = NULL;
unsigned char *srcData;
unsigned char *dstData;
unsigned char *dataP;
unsigned char *pixP;
int i;
int j;
int newNumLut;
int newTransIdx;
int jniFlag = JNI_ABORT;
unsigned char *ydataP;
unsigned char *ypixP;
unsigned char cvtLut[256];
if (JNU_IsNull(env, jlut)) {
JNU_ThrowNullPointerException(env, "NullPointerException");
return 0;
}
if (JNU_IsNull(env, jpix)) {
JNU_ThrowNullPointerException(env, "NullPointerException");
return 0;
}
sStride = (*env)->GetIntField(env, jbct, g_BCRscanstrID);
pixelStride =(*env)->GetIntField(env, jbct, g_BCRpixstrID);
jdata = (*env)->GetObjectField(env, jbct, g_BCRdataID);
jnewlut = (*env)->GetObjectField(env, jicm, g_ICMrgbID);
mapSize = (*env)->GetIntField(env, jicm, g_ICMmapSizeID);
if (numLut < 0 || numLut > 256 || mapSize < 0 || mapSize > 256) {
/* Ether old or new ICM has a palette that exceeds capacity
of byte data type, so we have to convert the image data
to default representation.
*/
return 0;
}
srcLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jlut,
NULL);
if (srcLUT == NULL) {
/* out of memory error already thrown */
return 0;
}
newLUT = (unsigned int *) (*env)->GetPrimitiveArrayCritical(env, jnewlut,
NULL);
if (newLUT == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT,
JNI_ABORT);
/* out of memory error already thrown */
return 0;
}
newNumLut = numLut;
newTransIdx = transIdx;
if (compareLUTs(srcLUT, numLut, transIdx, newLUT, mapSize,
cvtLut, &newNumLut, &newTransIdx, &jniFlag) == FALSE) {
/* Need to convert to ICR */
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT,
JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT);
return 0;
}
/* Don't need these any more */
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, jniFlag);
(*env)->ReleasePrimitiveArrayCritical(env, jnewlut, newLUT, JNI_ABORT);
if (newNumLut != numLut) {
/* Need to write back new number of entries in lut */
(*env)->SetIntField(env, cls, s_JnumSrcLUTID, newNumLut);
}
if (newTransIdx != transIdx) {
(*env)->SetIntField(env, cls, s_JsrcLUTtransIndexID, newTransIdx);
}
srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix,
NULL);
if (srcData == NULL) {
/* out of memory error already thrown */
return 0;
}
dstData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jdata,
NULL);
if (dstData == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
/* out of memory error already thrown */
return 0;
}
ydataP = dstData + chanOff + y*sStride + x*pixelStride;
ypixP = srcData + off;
for (i=0; i < h; i++) {
dataP = ydataP;
pixP = ypixP;
for (j=0; j < w; j++) {
*dataP = cvtLut[*pixP];
dataP += pixelStride;
pixP++;
}
ydataP += sStride;
ypixP += scansize;
}
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT);
return 1;
}
/*
* Class: sun_java2d_loops_DrawPolygons
* Method: DrawPolygons
* Signature: (Lsun/java2d/SunGraphics2D;Lsun/java2d/SurfaceData;[I[I[IIIIZ)V
*/
JNIEXPORT void JNICALL
Java_sun_java2d_loops_DrawPolygons_DrawPolygons
(JNIEnv *env, jobject self,
jobject sg2d, jobject sData,
jintArray xPointsArray, jintArray yPointsArray,
jintArray nPointsArray, jint numPolys,
jint transX, jint transY, jboolean close)
{
SurfaceDataOps *sdOps;
SurfaceDataRasInfo rasInfo;
NativePrimitive *pPrim;
CompositeInfo compInfo;
jsize nPointsLen, xPointsLen, yPointsLen;
jint *nPointsPtr = NULL;
jint *xPointsPtr = NULL;
jint *yPointsPtr = NULL;
jint pointsNeeded;
jint i, ret;
jboolean ok = JNI_TRUE;
jint pixel = GrPrim_Sg2dGetPixel(env, sg2d);
if (JNU_IsNull(env, xPointsArray) || JNU_IsNull(env, yPointsArray)) {
JNU_ThrowNullPointerException(env, "coordinate array");
return;
}
if (JNU_IsNull(env, nPointsArray)) {
JNU_ThrowNullPointerException(env, "polygon length array");
return;
}
nPointsLen = (*env)->GetArrayLength(env, nPointsArray);
xPointsLen = (*env)->GetArrayLength(env, xPointsArray);
yPointsLen = (*env)->GetArrayLength(env, yPointsArray);
if (nPointsLen < numPolys) {
JNU_ThrowArrayIndexOutOfBoundsException(env,
"polygon length array size");
return;
}
pPrim = GetNativePrim(env, self);
if (pPrim == NULL) {
return;
}
if (pPrim->pCompType->getCompInfo != NULL) {
GrPrim_Sg2dGetCompInfo(env, sg2d, pPrim, &compInfo);
}
sdOps = SurfaceData_GetOps(env, sData);
if (sdOps == 0) {
return;
}
GrPrim_Sg2dGetClip(env, sg2d, &rasInfo.bounds);
ret = sdOps->Lock(env, sdOps, &rasInfo, SD_LOCK_FASTEST | pPrim->dstflags);
if (ret == SD_FAILURE) {
return;
}
nPointsPtr = (*env)->GetPrimitiveArrayCritical(env, nPointsArray, NULL);
if (!nPointsPtr) {
ok = JNI_FALSE;
}
if (ok) {
pointsNeeded = 0;
for (i = 0; i < numPolys; i++) {
if (nPointsPtr[i] > 0) {
pointsNeeded += nPointsPtr[i];
}
}
if (yPointsLen < pointsNeeded || xPointsLen < pointsNeeded) {
(*env)->ReleasePrimitiveArrayCritical(env, nPointsArray,
nPointsPtr, JNI_ABORT);
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
JNU_ThrowArrayIndexOutOfBoundsException(env,
"coordinate array length");
return;
}
xPointsPtr = (*env)->GetPrimitiveArrayCritical(env, xPointsArray, NULL);
yPointsPtr = (*env)->GetPrimitiveArrayCritical(env, yPointsArray, NULL);
if (!xPointsPtr || !yPointsPtr) {
ok = JNI_FALSE;
}
}
if (ok) {
if (ret == SD_SLOWLOCK) {
RefineBounds(&rasInfo.bounds, transX, transY,
xPointsPtr, yPointsPtr, pointsNeeded);
ok = (rasInfo.bounds.x2 > rasInfo.bounds.x1 &&
rasInfo.bounds.y2 > rasInfo.bounds.y1);
}
}
if (ok) {
sdOps->GetRasInfo(env, sdOps, &rasInfo);
if (rasInfo.rasBase &&
rasInfo.bounds.x2 > rasInfo.bounds.x1 &&
rasInfo.bounds.y2 > rasInfo.bounds.y1)
{
ProcessPoly(&rasInfo, pPrim->funcs.drawline, pPrim, &compInfo,
pixel, transX, transY,
xPointsPtr, yPointsPtr,
nPointsPtr, numPolys,
close);
}
SurfaceData_InvokeRelease(env, sdOps, &rasInfo);
}
if (nPointsPtr) {
(*env)->ReleasePrimitiveArrayCritical(env, nPointsArray,
nPointsPtr, JNI_ABORT);
}
if (xPointsPtr) {
(*env)->ReleasePrimitiveArrayCritical(env, xPointsArray,
xPointsPtr, JNI_ABORT);
}
if (yPointsPtr) {
(*env)->ReleasePrimitiveArrayCritical(env, yPointsArray,
yPointsPtr, JNI_ABORT);
}
SurfaceData_InvokeUnlock(env, sdOps, &rasInfo);
}
JNIEXPORT jint JNICALL
Java_sun_java2d_pipe_BufferedRenderPipe_fillSpans
(JNIEnv *env, jobject pipe,
jobject rq, jlong buf,
jint bpos, jint limit,
jobject si, jlong pIterator,
jint transx, jint transy)
{
SpanIteratorFuncs *pFuncs = (SpanIteratorFuncs *)jlong_to_ptr(pIterator);
void *srData;
jint spanbox[4];
jint spanCount = 0;
jint remainingBytes, remainingSpans;
unsigned char *bbuf;
jint *ibuf;
jint ipos;
J2dTraceLn2(J2D_TRACE_INFO,
"BufferedRenderPipe_fillSpans: bpos=%d limit=%d",
bpos, limit);
if (JNU_IsNull(env, rq)) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedRenderPipe_fillSpans: rq is null");
return bpos;
}
if (JNU_IsNull(env, si)) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedRenderPipe_fillSpans: span iterator is null");
return bpos;
}
if (pFuncs == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedRenderPipe_fillSpans: native iterator not supplied");
return bpos;
}
bbuf = (unsigned char *)jlong_to_ptr(buf);
if (bbuf == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedRenderPipe_fillSpans: cannot get direct buffer address");
return bpos;
}
// adjust the int pointer to the current buffer position
ibuf = (jint *)(bbuf + bpos);
// start new operation
ibuf[0] = sun_java2d_pipe_BufferedOpCodes_FILL_SPANS;
ibuf[1] = 0; // placeholder for the span count
// skip the opcode and span count
ipos = INTS_PER_HEADER;
bpos += BYTES_PER_HEADER; // skip the opcode and span count
remainingBytes = limit - bpos;
remainingSpans = remainingBytes / BYTES_PER_SPAN;
srData = (*pFuncs->open)(env, si);
while ((*pFuncs->nextSpan)(srData, spanbox)) {
if (remainingSpans == 0) {
// fill in span count
ibuf[1] = spanCount;
// flush the queue
JNU_CallMethodByName(env, NULL, rq, "flushNow", "(I)V", bpos);
// now start a new operation
ibuf = (jint *)bbuf;
ibuf[0] = sun_java2d_pipe_BufferedOpCodes_FILL_SPANS;
ibuf[1] = 0; // placeholder for the span count
// skip the opcode and span count
ipos = INTS_PER_HEADER;
bpos = BYTES_PER_HEADER;
// calculate new limits
remainingBytes = limit - bpos;
remainingSpans = remainingBytes / BYTES_PER_SPAN;
spanCount = 0;
}
// enqueue span
ibuf[ipos++] = spanbox[0] + transx; // x1
ibuf[ipos++] = spanbox[1] + transy; // y1
ibuf[ipos++] = spanbox[2] + transx; // x2
ibuf[ipos++] = spanbox[3] + transy; // y2
// update positions
bpos += BYTES_PER_SPAN;
spanCount++;
remainingSpans--;
}
(*pFuncs->close)(env, srData);
// fill in span count
ibuf[1] = spanCount;
// return the current byte position
return bpos;
}
/*
* Class: sun_awt_windows_WClipboard
* Method: getClipboardData
* Signature: (J)[B
*/
JNIEXPORT jbyteArray JNICALL
Java_sun_awt_windows_WClipboard_getClipboardData
(JNIEnv *env, jobject self, jlong format)
{
TRY;
DASSERT(::GetOpenClipboardWindow() == AwtToolkit::GetInstance().GetHWnd());
HANDLE handle = ::GetClipboardData((UINT)format);
if (handle == NULL) {
JNU_ThrowIOException(env, "system clipboard data unavailable");
return NULL;
}
jbyteArray bytes = NULL;
jbyteArray paletteData = NULL;
switch (format) {
case CF_ENHMETAFILE:
case CF_METAFILEPICT: {
HENHMETAFILE hemf = NULL;
if (format == CF_METAFILEPICT) {
HMETAFILEPICT hMetaFilePict = (HMETAFILEPICT)handle;
LPMETAFILEPICT lpMetaFilePict =
(LPMETAFILEPICT)::GlobalLock(hMetaFilePict);
UINT uSize = ::GetMetaFileBitsEx(lpMetaFilePict->hMF, 0, NULL);
DASSERT(uSize != 0);
try {
LPBYTE lpMfBits = (LPBYTE)safe_Malloc(uSize);
VERIFY(::GetMetaFileBitsEx(lpMetaFilePict->hMF, uSize,
lpMfBits) == uSize);
hemf = ::SetWinMetaFileBits(uSize, lpMfBits, NULL,
lpMetaFilePict);
free(lpMfBits);
if (hemf == NULL) {
::GlobalUnlock(hMetaFilePict);
JNU_ThrowIOException(env, "failed to get system clipboard data");
return NULL;
}
} catch (...) {
::GlobalUnlock(hMetaFilePict);
throw;
}
::GlobalUnlock(hMetaFilePict);
} else {
hemf = (HENHMETAFILE)handle;
}
UINT uEmfSize = ::GetEnhMetaFileBits(hemf, 0, NULL);
if (uEmfSize == 0) {
JNU_ThrowIOException(env, "cannot retrieve metafile bits");
return NULL;
}
bytes = env->NewByteArray(uEmfSize);
if (bytes == NULL) {
throw std::bad_alloc();
}
LPBYTE lpbEmfBuffer =
(LPBYTE)env->GetPrimitiveArrayCritical(bytes, NULL);
if (lpbEmfBuffer == NULL) {
env->DeleteLocalRef(bytes);
throw std::bad_alloc();
}
VERIFY(::GetEnhMetaFileBits(hemf, uEmfSize, lpbEmfBuffer) == uEmfSize);
env->ReleasePrimitiveArrayCritical(bytes, lpbEmfBuffer, 0);
paletteData =
AwtDataTransferer::GetPaletteBytes(hemf, OBJ_ENHMETAFILE, FALSE);
break;
}
case CF_LOCALE: {
LCID *lcid = (LCID *)::GlobalLock(handle);
if (lcid == NULL) {
JNU_ThrowIOException(env, "invalid LCID");
return NULL;
}
try {
bytes = AwtDataTransferer::LCIDToTextEncoding(env, *lcid);
} catch (...) {
::GlobalUnlock(handle);
throw;
}
::GlobalUnlock(handle);
break;
}
default: {
::SetLastError(0); // clear error
// Warning C4244.
// Cast SIZE_T (__int64 on 64-bit/unsigned int on 32-bit)
// to jsize (long).
SIZE_T globalSize = ::GlobalSize(handle);
jsize size = (globalSize <= INT_MAX) ? (jsize)globalSize : INT_MAX;
if (::GetLastError() != 0) {
JNU_ThrowIOException(env, "invalid global memory block handle");
return NULL;
}
bytes = env->NewByteArray(size);
if (bytes == NULL) {
throw std::bad_alloc();
}
if (size != 0) {
LPVOID data = ::GlobalLock(handle);
env->SetByteArrayRegion(bytes, 0, size, (jbyte *)data);
::GlobalUnlock(handle);
}
break;
}
}
switch (format) {
case CF_ENHMETAFILE:
case CF_METAFILEPICT:
case CF_DIB: {
if (JNU_IsNull(env, paletteData)) {
HPALETTE hPalette = (HPALETTE)::GetClipboardData(CF_PALETTE);
paletteData =
AwtDataTransferer::GetPaletteBytes(hPalette, OBJ_PAL, TRUE);
}
DASSERT(!JNU_IsNull(env, paletteData) &&
!JNU_IsNull(env, bytes));
jbyteArray concat =
(jbyteArray)AwtDataTransferer::ConcatData(env, paletteData, bytes);
if (!JNU_IsNull(env, safe_ExceptionOccurred(env))) {
env->ExceptionDescribe();
env->ExceptionClear();
env->DeleteLocalRef(bytes);
env->DeleteLocalRef(paletteData);
return NULL;
}
env->DeleteLocalRef(bytes);
env->DeleteLocalRef(paletteData);
bytes = concat;
break;
}
}
return bytes;
CATCH_BAD_ALLOC_RET(NULL);
}
/**
* This implementation of MaskBlit first combines the source system memory
* tile with the corresponding alpha mask and stores the resulting
* IntArgbPre pixels directly into the RenderBuffer. Those pixels are
* then eventually pulled off the RenderBuffer and copied to the destination
* surface in OGL/D3DMaskBlit.
*
* Note that currently there are only inner loops defined for IntArgb,
* IntArgbPre, IntRgb, and IntBgr, as those are the most commonly used
* formats for this operation.
*/
JNIEXPORT jint JNICALL
Java_sun_java2d_pipe_BufferedMaskBlit_enqueueTile
(JNIEnv *env, jobject mb,
jlong buf, jint bpos,
jobject srcData, jlong pSrcOps, jint srcType,
jbyteArray maskArray, jint masklen, jint maskoff, jint maskscan,
jint srcx, jint srcy, jint dstx, jint dsty,
jint width, jint height)
{
SurfaceDataOps *srcOps = (SurfaceDataOps *)jlong_to_ptr(pSrcOps);
SurfaceDataRasInfo srcInfo;
unsigned char *pMask;
unsigned char *bbuf;
jint *pBuf;
J2dTraceLn1(J2D_TRACE_INFO,
"BufferedMaskBlit_enqueueTile: bpos=%d",
bpos);
if (srcOps == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedMaskBlit_enqueueTile: srcOps is null");
return bpos;
}
bbuf = (unsigned char *)jlong_to_ptr(buf);
if (bbuf == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedMaskBlit_enqueueTile: cannot get direct buffer address");
return bpos;
}
pBuf = (jint *)(bbuf + bpos);
if (JNU_IsNull(env, maskArray)) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedMaskBlit_enqueueTile: mask array is null");
return bpos;
}
if (masklen > MAX_MASK_LENGTH) {
// REMIND: this approach is seriously flawed if the mask
// length is ever greater than MAX_MASK_LENGTH (won't fit
// into the cached mask tile); so far this hasn't
// been a problem though...
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedMaskBlit_enqueueTile: mask array too large");
return bpos;
}
pMask = (*env)->GetPrimitiveArrayCritical(env, maskArray, 0);
if (pMask == NULL) {
J2dRlsTraceLn(J2D_TRACE_ERROR,
"BufferedMaskBlit_enqueueTile: cannot lock mask array");
return bpos;
}
srcInfo.bounds.x1 = srcx;
srcInfo.bounds.y1 = srcy;
srcInfo.bounds.x2 = srcx + width;
srcInfo.bounds.y2 = srcy + height;
if (srcOps->Lock(env, srcOps, &srcInfo, SD_LOCK_READ) != SD_SUCCESS) {
J2dRlsTraceLn(J2D_TRACE_WARNING,
"BufferedMaskBlit_enqueueTile: could not acquire lock");
(*env)->ReleasePrimitiveArrayCritical(env, maskArray,
pMask, JNI_ABORT);
return bpos;
}
if (srcInfo.bounds.x2 > srcInfo.bounds.x1 &&
srcInfo.bounds.y2 > srcInfo.bounds.y1)
{
srcOps->GetRasInfo(env, srcOps, &srcInfo);
if (srcInfo.rasBase) {
jint h;
jint srcScanStride = srcInfo.scanStride;
jint srcPixelStride = srcInfo.pixelStride;
jint *pSrc = (jint *)
PtrCoord(srcInfo.rasBase,
srcInfo.bounds.x1, srcInfo.pixelStride,
srcInfo.bounds.y1, srcInfo.scanStride);
width = srcInfo.bounds.x2 - srcInfo.bounds.x1;
height = srcInfo.bounds.y2 - srcInfo.bounds.y1;
maskoff += ((srcInfo.bounds.y1 - srcy) * maskscan +
(srcInfo.bounds.x1 - srcx));
maskscan -= width;
pMask += maskoff;
srcScanStride -= width * srcPixelStride;
h = height;
J2dTraceLn4(J2D_TRACE_VERBOSE,
" sx=%d sy=%d w=%d h=%d",
srcInfo.bounds.x1, srcInfo.bounds.y1, width, height);
J2dTraceLn2(J2D_TRACE_VERBOSE,
" maskoff=%d maskscan=%d",
maskoff, maskscan);
J2dTraceLn2(J2D_TRACE_VERBOSE,
" pixstride=%d scanstride=%d",
srcPixelStride, srcScanStride);
// enqueue parameters
pBuf[0] = sun_java2d_pipe_BufferedOpCodes_MASK_BLIT;
pBuf[1] = dstx;
pBuf[2] = dsty;
pBuf[3] = width;
pBuf[4] = height;
pBuf += 5;
bpos += 5 * sizeof(jint);
// apply alpha values from mask to the source tile, and store
// resulting IntArgbPre pixels into RenderBuffer (there are
// separate inner loops for the most common source formats)
switch (srcType) {
case sun_java2d_pipe_BufferedMaskBlit_ST_INT_ARGB:
do {
jint w = width;
do {
jubyte pathA = *pMask++;
if (!pathA) {
pBuf[0] = 0;
} else {
jint cr, cg, cb, ca;
jubyte r, g, b, a;
LoadIntArgbTo4ByteArgb(pSrc, c, 0, ca, cr, cg, cb);
a = MUL8(ca, pathA);
r = MUL8(cr, a);
g = MUL8(cg, a);
b = MUL8(cb, a);
pBuf[0] = (a << 24) | (r << 16) | (g << 8) | b;
}
pSrc = PtrAddBytes(pSrc, srcPixelStride);
pBuf++;
} while (--w > 0);
pSrc = PtrAddBytes(pSrc, srcScanStride);
pMask = PtrAddBytes(pMask, maskscan);
} while (--h > 0);
break;
case sun_java2d_pipe_BufferedMaskBlit_ST_INT_ARGB_PRE:
do {
jint w = width;
do {
jubyte pathA = *pMask++;
if (!pathA) {
pBuf[0] = 0;
} else if (pathA == 0xff) {
pBuf[0] = pSrc[0];
} else {
jubyte r, g, b, a;
a = MUL8((pSrc[0] >> 24) & 0xff, pathA);
r = MUL8((pSrc[0] >> 16) & 0xff, pathA);
g = MUL8((pSrc[0] >> 8) & 0xff, pathA);
b = MUL8((pSrc[0] >> 0) & 0xff, pathA);
pBuf[0] = (a << 24) | (r << 16) | (g << 8) | b;
}
pSrc = PtrAddBytes(pSrc, srcPixelStride);
pBuf++;
} while (--w > 0);
pSrc = PtrAddBytes(pSrc, srcScanStride);
pMask = PtrAddBytes(pMask, maskscan);
} while (--h > 0);
break;
case sun_java2d_pipe_BufferedMaskBlit_ST_INT_RGB:
do {
jint w = width;
do {
jubyte pathA = *pMask++;
if (!pathA) {
pBuf[0] = 0;
} else {
jint cr, cg, cb;
jubyte r, g, b, a;
LoadIntRgbTo3ByteRgb(pSrc, c, 0, cr, cg, cb);
a = pathA;
r = MUL8(cr, a);
g = MUL8(cg, a);
b = MUL8(cb, a);
pBuf[0] = (a << 24) | (r << 16) | (g << 8) | b;
}
pSrc = PtrAddBytes(pSrc, srcPixelStride);
pBuf++;
} while (--w > 0);
pSrc = PtrAddBytes(pSrc, srcScanStride);
pMask = PtrAddBytes(pMask, maskscan);
} while (--h > 0);
break;
case sun_java2d_pipe_BufferedMaskBlit_ST_INT_BGR:
do {
jint w = width;
do {
jubyte pathA = *pMask++;
if (!pathA) {
pBuf[0] = 0;
} else {
jint cr, cg, cb;
jubyte r, g, b, a;
LoadIntBgrTo3ByteRgb(pSrc, c, 0, cr, cg, cb);
a = pathA;
r = MUL8(cr, a);
g = MUL8(cg, a);
b = MUL8(cb, a);
pBuf[0] = (a << 24) | (r << 16) | (g << 8) | b;
}
pSrc = PtrAddBytes(pSrc, srcPixelStride);
pBuf++;
} while (--w > 0);
pSrc = PtrAddBytes(pSrc, srcScanStride);
pMask = PtrAddBytes(pMask, maskscan);
} while (--h > 0);
break;
default:
// should not get here, just no-op...
break;
}
// increment current byte position
bpos += width * height * sizeof(jint);
}
/*
* This routine is used to draw ICM pixels into a default color model
*/
JNIEXPORT jboolean JNICALL
Java_sun_awt_image_ImageRepresentation_setICMpixels(JNIEnv *env, jclass cls,
jint x, jint y, jint w,
jint h, jintArray jlut,
jbyteArray jpix, jint off,
jint scansize,
jobject jict)
{
unsigned char *srcData = NULL;
jint srcDataLength;
int *dstData;
jint dstDataLength;
jint dstDataOff;
int *dstP, *dstyP;
unsigned char *srcyP, *srcP;
int *srcLUT = NULL;
int yIdx, xIdx;
int sStride;
int *cOffs;
int pixelStride;
jobject joffs = NULL;
jobject jdata = NULL;
if (JNU_IsNull(env, jlut)) {
JNU_ThrowNullPointerException(env, "NullPointerException");
return JNI_FALSE;
}
if (JNU_IsNull(env, jpix)) {
JNU_ThrowNullPointerException(env, "NullPointerException");
return JNI_FALSE;
}
if (x < 0 || w < 1 || (0x7fffffff - x) < w) {
return JNI_FALSE;
}
if (y < 0 || h < 1 || (0x7fffffff - y) < h) {
return JNI_FALSE;
}
sStride = (*env)->GetIntField(env, jict, g_ICRscanstrID);
pixelStride = (*env)->GetIntField(env, jict, g_ICRpixstrID);
joffs = (*env)->GetObjectField(env, jict, g_ICRdataOffsetsID);
jdata = (*env)->GetObjectField(env, jict, g_ICRdataID);
if (JNU_IsNull(env, jdata)) {
/* no destination buffer */
return JNI_FALSE;
}
if (JNU_IsNull(env, joffs) || (*env)->GetArrayLength(env, joffs) < 1) {
/* invalid data offstes in raster */
return JNI_FALSE;
}
srcDataLength = (*env)->GetArrayLength(env, jpix);
dstDataLength = (*env)->GetArrayLength(env, jdata);
cOffs = (int *) (*env)->GetPrimitiveArrayCritical(env, joffs, NULL);
if (cOffs == NULL) {
JNU_ThrowNullPointerException(env, "Null channel offset array");
return JNI_FALSE;
}
dstDataOff = cOffs[0];
/* the offset array is not needed anymore and can be released */
(*env)->ReleasePrimitiveArrayCritical(env, joffs, cOffs, JNI_ABORT);
joffs = NULL;
cOffs = NULL;
/* do basic validation: make sure that offsets for
* first pixel and for last pixel are safe to calculate and use */
CHECK_STRIDE(y, h, sStride);
CHECK_STRIDE(x, w, pixelStride);
CHECK_DST(x, y);
CHECK_DST(x + w -1, y + h - 1);
/* check source array */
CHECK_SRC();
srcLUT = (int *) (*env)->GetPrimitiveArrayCritical(env, jlut, NULL);
if (srcLUT == NULL) {
JNU_ThrowNullPointerException(env, "Null IndexColorModel LUT");
return JNI_FALSE;
}
srcData = (unsigned char *) (*env)->GetPrimitiveArrayCritical(env, jpix,
NULL);
if (srcData == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
JNU_ThrowNullPointerException(env, "Null data array");
return JNI_FALSE;
}
dstData = (int *) (*env)->GetPrimitiveArrayCritical(env, jdata, NULL);
if (dstData == NULL) {
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
JNU_ThrowNullPointerException(env, "Null tile data array");
return JNI_FALSE;
}
dstyP = dstData + dstDataOff + y*sStride + x*pixelStride;
srcyP = srcData + off;
for (yIdx = 0; yIdx < h; yIdx++, srcyP += scansize, dstyP+=sStride) {
srcP = srcyP;
dstP = dstyP;
for (xIdx = 0; xIdx < w; xIdx++, dstP+=pixelStride) {
*dstP = srcLUT[*srcP++];
}
}
/* Release the locked arrays */
(*env)->ReleasePrimitiveArrayCritical(env, jlut, srcLUT, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jpix, srcData, JNI_ABORT);
(*env)->ReleasePrimitiveArrayCritical(env, jdata, dstData, JNI_ABORT);
return JNI_TRUE;
}
