From c04326d7ca09c8cd2169f4c75a197adfc3010a51 Mon Sep 17 00:00:00 2001 From: Mathew Inwood Date: Thu, 9 Aug 2018 17:38:56 +0100 Subject: Add @UnsupportedAppUsage annotations For packages: android.opengl This is an automatically generated CL. See go/UnsupportedAppUsage for more details. Exempted-From-Owner-Approval: Mechanical changes to the codebase which have been approved by Android API council and announced on android-eng@ Bug: 110868826 Test: m Change-Id: I747cf5d5e6e211dc368545472fee65fd20cdae74 --- opengl/java/android/opengl/EGL14.java | 2 ++ opengl/java/android/opengl/GLES20.java | 4 ++++ opengl/java/android/opengl/GLSurfaceView.java | 5 +++++ 3 files changed, 11 insertions(+) (limited to 'opengl/java') diff --git a/opengl/java/android/opengl/EGL14.java b/opengl/java/android/opengl/EGL14.java index 53ec6c8980ef..728e6e18cc31 100644 --- a/opengl/java/android/opengl/EGL14.java +++ b/opengl/java/android/opengl/EGL14.java @@ -18,6 +18,7 @@ package android.opengl; +import android.annotation.UnsupportedAppUsage; import android.graphics.SurfaceTexture; import android.view.Surface; import android.view.SurfaceView; @@ -163,6 +164,7 @@ public static final int EGL_CORE_NATIVE_ENGINE = 0x305B; /** * {@hide} */ + @UnsupportedAppUsage public static native EGLDisplay eglGetDisplay( long display_id ); diff --git a/opengl/java/android/opengl/GLES20.java b/opengl/java/android/opengl/GLES20.java index 137f2f5c2c5e..d66e7ac84a3b 100644 --- a/opengl/java/android/opengl/GLES20.java +++ b/opengl/java/android/opengl/GLES20.java @@ -19,6 +19,8 @@ package android.opengl; +import android.annotation.UnsupportedAppUsage; + /** OpenGL ES 2.0 */ public class GLES20 { @@ -824,6 +826,7 @@ public class GLES20 { // C function void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) /** @hide Method is broken, but used to be public (b/6006380) */ + @UnsupportedAppUsage public static native void glGetActiveAttrib( int program, int index, @@ -872,6 +875,7 @@ public class GLES20 { // C function void glGetActiveUniform ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) /** @hide Method is broken, but used to be public (b/6006380) */ + @UnsupportedAppUsage public static native void glGetActiveUniform( int program, int index, diff --git a/opengl/java/android/opengl/GLSurfaceView.java b/opengl/java/android/opengl/GLSurfaceView.java index 0f0a7e9d1314..8a3e6a0b0fd5 100644 --- a/opengl/java/android/opengl/GLSurfaceView.java +++ b/opengl/java/android/opengl/GLSurfaceView.java @@ -16,6 +16,7 @@ package android.opengl; +import android.annotation.UnsupportedAppUsage; import android.content.Context; import android.os.Trace; import android.util.AttributeSet; @@ -1235,6 +1236,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback EGLDisplay mEglDisplay; EGLSurface mEglSurface; EGLConfig mEglConfig; + @UnsupportedAppUsage EGLContext mEglContext; } @@ -1844,6 +1846,7 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback // End of member variables protected by the sGLThreadManager monitor. + @UnsupportedAppUsage private EglHelper mEglHelper; /** @@ -1919,7 +1922,9 @@ public class GLSurfaceView extends SurfaceView implements SurfaceHolder.Callback private final WeakReference mThisWeakRef = new WeakReference(this); + @UnsupportedAppUsage private GLThread mGLThread; + @UnsupportedAppUsage private Renderer mRenderer; private boolean mDetached; private EGLConfigChooser mEGLConfigChooser; -- cgit v1.2.3-59-g8ed1b From b6c9782f5a61a9cf7e9bdacfe2db9e044a545224 Mon Sep 17 00:00:00 2001 From: Mathew Inwood Date: Fri, 17 Aug 2018 15:23:54 +0100 Subject: Add @UnsupportedAppUsage annotations For packages: javax.microedition.khronos.opengles javax.microedition.khronos.egl This is an automatically generated CL. See go/UnsupportedAppUsage for more details. Exempted-From-Owner-Approval: Mechanical changes to the codebase which have been approved by Android API council and announced on android-eng@ Bug: 110868826 Test: m Change-Id: I3615f60789c14c44284c896c3a9ea291100dff8e --- config/hiddenapi-light-greylist.txt | 1 - opengl/java/javax/microedition/khronos/egl/EGL10.java | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-) (limited to 'opengl/java') diff --git a/config/hiddenapi-light-greylist.txt b/config/hiddenapi-light-greylist.txt index 0e0a8c77eac6..f51afce8a6ef 100644 --- a/config/hiddenapi-light-greylist.txt +++ b/config/hiddenapi-light-greylist.txt @@ -5552,7 +5552,6 @@ Ljava/util/zip/ZipInputStream;->tmpbuf:[B Ljava/util/zip/ZipOutputStream;->method:I Ljava/util/zip/ZipOutputStream;->names:Ljava/util/HashSet; Ljava/util/zip/ZipOutputStream;->written:J -Ljavax/microedition/khronos/egl/EGL10;->eglReleaseThread()Z Ljavax/net/ssl/SSLServerSocketFactory;->defaultServerSocketFactory:Ljavax/net/ssl/SSLServerSocketFactory; Ljavax/net/ssl/SSLSocketFactory;->createSocket(Ljava/net/Socket;Ljava/io/InputStream;Z)Ljava/net/Socket; Ljavax/net/ssl/SSLSocketFactory;->defaultSocketFactory:Ljavax/net/ssl/SSLSocketFactory; diff --git a/opengl/java/javax/microedition/khronos/egl/EGL10.java b/opengl/java/javax/microedition/khronos/egl/EGL10.java index 612d59c53e9f..8a2517062d4d 100644 --- a/opengl/java/javax/microedition/khronos/egl/EGL10.java +++ b/opengl/java/javax/microedition/khronos/egl/EGL10.java @@ -16,6 +16,7 @@ package javax.microedition.khronos.egl; +import android.annotation.UnsupportedAppUsage; import java.lang.String; public interface EGL10 extends EGL { @@ -116,6 +117,7 @@ public interface EGL10 extends EGL { String eglQueryString(EGLDisplay display, int name); boolean eglQuerySurface(EGLDisplay display, EGLSurface surface, int attribute, int[] value); /** @hide **/ + @UnsupportedAppUsage boolean eglReleaseThread(); boolean eglSwapBuffers(EGLDisplay display, EGLSurface surface); boolean eglTerminate(EGLDisplay display); -- cgit v1.2.3-59-g8ed1b From 367ed8b190e259335a295f1f6c8cba63e7b76fcd Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Wed, 18 Jul 2018 10:45:37 -0600 Subject: Update to EGL 1.5 Test: compile Bug: 80239516 Change-Id: I1c00ac5e55900260b724e1c298edca15f87f3a01 (cherry picked from commit 63584195b9d15daa9973d280381fd619cd7a0f89) --- api/current.txt | 65 ++++ config/preloaded-classes | 1 + core/jni/Android.bp | 1 + core/jni/AndroidRuntime.cpp | 2 + core/jni/android_opengl_EGL15.cpp | 557 +++++++++++++++++++++++++++++++ opengl/java/android/opengl/EGL15.java | 149 +++++++++ opengl/java/android/opengl/EGLImage.java | 37 ++ opengl/java/android/opengl/EGLSync.java | 37 ++ 8 files changed, 849 insertions(+) create mode 100644 core/jni/android_opengl_EGL15.cpp create mode 100644 opengl/java/android/opengl/EGL15.java create mode 100644 opengl/java/android/opengl/EGLImage.java create mode 100644 opengl/java/android/opengl/EGLSync.java (limited to 'opengl/java') diff --git a/api/current.txt b/api/current.txt index 0ffa38b6360a..845b7f874b19 100755 --- a/api/current.txt +++ b/api/current.txt @@ -29714,6 +29714,65 @@ package android.opengl { field public static final int EGL_WINDOW_BIT = 4; // 0x4 } + public class EGL15 { + ctor public EGL15(); + method public static int eglClientWaitSync(android.opengl.EGLDisplay, android.opengl.EGLSync, int, long); + method public static android.opengl.EGLSurface eglCreatePlatformPixmapSurface(android.opengl.EGLDisplay, android.opengl.EGLConfig, java.nio.Buffer, long[], int); + method public static android.opengl.EGLSurface eglCreatePlatformWindowSurface(android.opengl.EGLDisplay, android.opengl.EGLConfig, java.nio.Buffer, long[], int); + method public static android.opengl.EGLSync eglCreateSync(android.opengl.EGLDisplay, int, long[], int); + method public static boolean eglDestroySync(android.opengl.EGLDisplay, android.opengl.EGLSync); + method public static android.opengl.EGLDisplay eglGetPlatformDisplay(int, long, long[], int); + method public static boolean eglGetSyncAttrib(android.opengl.EGLDisplay, android.opengl.EGLSync, int, long[], int); + method public static boolean eglWaitSync(android.opengl.EGLDisplay, android.opengl.EGLSync, int); + field public static final int EGL_CL_EVENT_HANDLE = 12444; // 0x309c + field public static final int EGL_CONDITION_SATISFIED = 12534; // 0x30f6 + field public static final int EGL_CONTEXT_MAJOR_VERSION = 12440; // 0x3098 + field public static final int EGL_CONTEXT_MINOR_VERSION = 12539; // 0x30fb + field public static final int EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT = 2; // 0x2 + field public static final int EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT = 1; // 0x1 + field public static final int EGL_CONTEXT_OPENGL_DEBUG = 12720; // 0x31b0 + field public static final int EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE = 12721; // 0x31b1 + field public static final int EGL_CONTEXT_OPENGL_PROFILE_MASK = 12541; // 0x30fd + field public static final int EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY = 12733; // 0x31bd + field public static final int EGL_CONTEXT_OPENGL_ROBUST_ACCESS = 12722; // 0x31b2 + field public static final long EGL_FOREVER = -1L; // 0xffffffffffffffffL + field public static final int EGL_GL_COLORSPACE = 12445; // 0x309d + field public static final int EGL_GL_COLORSPACE_LINEAR = 12426; // 0x308a + field public static final int EGL_GL_COLORSPACE_SRGB = 12425; // 0x3089 + field public static final int EGL_GL_RENDERBUFFER = 12473; // 0x30b9 + field public static final int EGL_GL_TEXTURE_2D = 12465; // 0x30b1 + field public static final int EGL_GL_TEXTURE_3D = 12466; // 0x30b2 + field public static final int EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 12468; // 0x30b4 + field public static final int EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 12470; // 0x30b6 + field public static final int EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 12472; // 0x30b8 + field public static final int EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X = 12467; // 0x30b3 + field public static final int EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 12469; // 0x30b5 + field public static final int EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 12471; // 0x30b7 + field public static final int EGL_GL_TEXTURE_LEVEL = 12476; // 0x30bc + field public static final int EGL_GL_TEXTURE_ZOFFSET = 12477; // 0x30bd + field public static final int EGL_IMAGE_PRESERVED = 12498; // 0x30d2 + field public static final int EGL_LOSE_CONTEXT_ON_RESET = 12735; // 0x31bf + field public static final android.opengl.EGLContext EGL_NO_CONTEXT; + field public static final android.opengl.EGLDisplay EGL_NO_DISPLAY; + field public static final android.opengl.EGLImage EGL_NO_IMAGE; + field public static final int EGL_NO_RESET_NOTIFICATION = 12734; // 0x31be + field public static final android.opengl.EGLSurface EGL_NO_SURFACE; + field public static final android.opengl.EGLSync EGL_NO_SYNC; + field public static final int EGL_OPENGL_ES3_BIT = 64; // 0x40 + field public static final int EGL_PLATFORM_ANDROID_KHR = 12609; // 0x3141 + field public static final int EGL_SIGNALED = 12530; // 0x30f2 + field public static final int EGL_SYNC_CL_EVENT = 12542; // 0x30fe + field public static final int EGL_SYNC_CL_EVENT_COMPLETE = 12543; // 0x30ff + field public static final int EGL_SYNC_CONDITION = 12536; // 0x30f8 + field public static final int EGL_SYNC_FENCE = 12537; // 0x30f9 + field public static final int EGL_SYNC_FLUSH_COMMANDS_BIT = 1; // 0x1 + field public static final int EGL_SYNC_PRIOR_COMMANDS_COMPLETE = 12528; // 0x30f0 + field public static final int EGL_SYNC_STATUS = 12529; // 0x30f1 + field public static final int EGL_SYNC_TYPE = 12535; // 0x30f7 + field public static final int EGL_TIMEOUT_EXPIRED = 12533; // 0x30f5 + field public static final int EGL_UNSIGNALED = 12531; // 0x30f3 + } + public class EGLConfig extends android.opengl.EGLObjectHandle { } @@ -29733,6 +29792,9 @@ package android.opengl { field public static final int EGL_RECORDABLE_ANDROID = 12610; // 0x3142 } + public class EGLImage extends android.opengl.EGLObjectHandle { + } + public abstract class EGLObjectHandle { ctor protected deprecated EGLObjectHandle(int); ctor protected EGLObjectHandle(long); @@ -29743,6 +29805,9 @@ package android.opengl { public class EGLSurface extends android.opengl.EGLObjectHandle { } + public class EGLSync extends android.opengl.EGLObjectHandle { + } + public class ETC1 { ctor public ETC1(); method public static void decodeBlock(java.nio.Buffer, java.nio.Buffer); diff --git a/config/preloaded-classes b/config/preloaded-classes index 56ca98ff9888..1a8a32ec574f 100644 --- a/config/preloaded-classes +++ b/config/preloaded-classes @@ -2354,6 +2354,7 @@ android.nfc.NfcAdapter$1 android.nfc.NfcAdapter$CreateNdefMessageCallback android.nfc.NfcManager android.opengl.EGL14 +android.opengl.EGL15 android.opengl.EGLConfig android.opengl.EGLContext android.opengl.EGLDisplay diff --git a/core/jni/Android.bp b/core/jni/Android.bp index ed6445d92b13..c6a612ec8877 100644 --- a/core/jni/Android.bp +++ b/core/jni/Android.bp @@ -45,6 +45,7 @@ cc_library_shared { "android_app_NativeActivity.cpp", "android_app_admin_SecurityLog.cpp", "android_opengl_EGL14.cpp", + "android_opengl_EGL15.cpp", "android_opengl_EGLExt.cpp", "android_opengl_GLES10.cpp", "android_opengl_GLES10Ext.cpp", diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp index c05bad2a4332..eada69097d05 100644 --- a/core/jni/AndroidRuntime.cpp +++ b/core/jni/AndroidRuntime.cpp @@ -77,6 +77,7 @@ extern int register_android_graphics_YuvImage(JNIEnv* env); extern int register_com_google_android_gles_jni_EGLImpl(JNIEnv* env); extern int register_com_google_android_gles_jni_GLImpl(JNIEnv* env); extern int register_android_opengl_jni_EGL14(JNIEnv* env); +extern int register_android_opengl_jni_EGL15(JNIEnv* env); extern int register_android_opengl_jni_EGLExt(JNIEnv* env); extern int register_android_opengl_jni_GLES10(JNIEnv* env); extern int register_android_opengl_jni_GLES10Ext(JNIEnv* env); @@ -1367,6 +1368,7 @@ static const RegJNIRec gRegJNI[] = { REG_JNI(register_com_google_android_gles_jni_EGLImpl), REG_JNI(register_com_google_android_gles_jni_GLImpl), REG_JNI(register_android_opengl_jni_EGL14), + REG_JNI(register_android_opengl_jni_EGL15), REG_JNI(register_android_opengl_jni_EGLExt), REG_JNI(register_android_opengl_jni_GLES10), REG_JNI(register_android_opengl_jni_GLES10Ext), diff --git a/core/jni/android_opengl_EGL15.cpp b/core/jni/android_opengl_EGL15.cpp new file mode 100644 index 000000000000..4a30babafa49 --- /dev/null +++ b/core/jni/android_opengl_EGL15.cpp @@ -0,0 +1,557 @@ +/* +** Copyright 2018, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#pragma GCC diagnostic ignored "-Wunused-variable" +#pragma GCC diagnostic ignored "-Wunused-function" + +#include "jni.h" +#include +#include +#include + +#include +#include + +#include + +static int initialized = 0; + +// classes from EGL 1.4 +static jclass egldisplayClass; +static jclass eglsurfaceClass; +static jclass eglconfigClass; +static jclass eglcontextClass; +static jclass bufferClass; +static jclass nioAccessClass; + +static jfieldID positionID; +static jfieldID limitID; +static jfieldID elementSizeShiftID; + +static jmethodID getBasePointerID; +static jmethodID getBaseArrayID; +static jmethodID getBaseArrayOffsetID; + +static jmethodID egldisplayGetHandleID; +static jmethodID eglconfigGetHandleID; +static jmethodID eglcontextGetHandleID; +static jmethodID eglsurfaceGetHandleID; + +static jmethodID egldisplayConstructor; +static jmethodID eglcontextConstructor; +static jmethodID eglsurfaceConstructor; +static jmethodID eglconfigConstructor; + +static jobject eglNoContextObject; +static jobject eglNoDisplayObject; +static jobject eglNoSurfaceObject; + +// classes from EGL 1.5 +static jclass eglimageClass; +static jclass eglsyncClass; + +static jmethodID eglimageGetHandleID; +static jmethodID eglsyncGetHandleID; + +static jmethodID eglimageConstructor; +static jmethodID eglsyncConstructor; + +static jobject eglNoImageObject; +static jobject eglNoSyncObject; + +/* Cache method IDs each time the class is loaded. */ + +static void +nativeClassInit(JNIEnv *_env, jclass glImplClass) +{ + // EGL 1.4 Init + jclass eglconfigClassLocal = _env->FindClass("android/opengl/EGLConfig"); + eglconfigClass = (jclass) _env->NewGlobalRef(eglconfigClassLocal); + jclass eglcontextClassLocal = _env->FindClass("android/opengl/EGLContext"); + eglcontextClass = (jclass) _env->NewGlobalRef(eglcontextClassLocal); + jclass egldisplayClassLocal = _env->FindClass("android/opengl/EGLDisplay"); + egldisplayClass = (jclass) _env->NewGlobalRef(egldisplayClassLocal); + jclass eglsurfaceClassLocal = _env->FindClass("android/opengl/EGLSurface"); + eglsurfaceClass = (jclass) _env->NewGlobalRef(eglsurfaceClassLocal); + + eglconfigGetHandleID = _env->GetMethodID(eglconfigClass, "getNativeHandle", "()J"); + eglcontextGetHandleID = _env->GetMethodID(eglcontextClass, "getNativeHandle", "()J"); + egldisplayGetHandleID = _env->GetMethodID(egldisplayClass, "getNativeHandle", "()J"); + eglsurfaceGetHandleID = _env->GetMethodID(eglsurfaceClass, "getNativeHandle", "()J"); + + + eglconfigConstructor = _env->GetMethodID(eglconfigClass, "", "(J)V"); + eglcontextConstructor = _env->GetMethodID(eglcontextClass, "", "(J)V"); + egldisplayConstructor = _env->GetMethodID(egldisplayClass, "", "(J)V"); + eglsurfaceConstructor = _env->GetMethodID(eglsurfaceClass, "", "(J)V"); + + jobject localeglNoContextObject = _env->NewObject(eglcontextClass, eglcontextConstructor, reinterpret_cast(EGL_NO_CONTEXT)); + eglNoContextObject = _env->NewGlobalRef(localeglNoContextObject); + jobject localeglNoDisplayObject = _env->NewObject(egldisplayClass, egldisplayConstructor, reinterpret_cast(EGL_NO_DISPLAY)); + eglNoDisplayObject = _env->NewGlobalRef(localeglNoDisplayObject); + jobject localeglNoSurfaceObject = _env->NewObject(eglsurfaceClass, eglsurfaceConstructor, reinterpret_cast(EGL_NO_SURFACE)); + eglNoSurfaceObject = _env->NewGlobalRef(localeglNoSurfaceObject); + + + jclass eglClass = _env->FindClass("android/opengl/EGL15"); + jfieldID noContextFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_CONTEXT", "Landroid/opengl/EGLContext;"); + _env->SetStaticObjectField(eglClass, noContextFieldID, eglNoContextObject); + + jfieldID noDisplayFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_DISPLAY", "Landroid/opengl/EGLDisplay;"); + _env->SetStaticObjectField(eglClass, noDisplayFieldID, eglNoDisplayObject); + + jfieldID noSurfaceFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_SURFACE", "Landroid/opengl/EGLSurface;"); + _env->SetStaticObjectField(eglClass, noSurfaceFieldID, eglNoSurfaceObject); + + // EGL 1.5 init + jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess"); + nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal); + + jclass bufferClassLocal = _env->FindClass("java/nio/Buffer"); + bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal); + + getBasePointerID = _env->GetStaticMethodID(nioAccessClass, + "getBasePointer", "(Ljava/nio/Buffer;)J"); + getBaseArrayID = _env->GetStaticMethodID(nioAccessClass, + "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); + getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass, + "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); + + positionID = _env->GetFieldID(bufferClass, "position", "I"); + limitID = _env->GetFieldID(bufferClass, "limit", "I"); + elementSizeShiftID = + _env->GetFieldID(bufferClass, "_elementSizeShift", "I"); + + jclass eglimageClassLocal = _env->FindClass("android/opengl/EGLImage"); + eglimageClass = (jclass) _env->NewGlobalRef(eglimageClassLocal); + jclass eglsyncClassLocal = _env->FindClass("android/opengl/EGLSync"); + eglsyncClass = (jclass) _env->NewGlobalRef(eglsyncClassLocal); + + eglimageGetHandleID = _env->GetMethodID(eglimageClass, "getNativeHandle", "()J"); + eglsyncGetHandleID = _env->GetMethodID(eglsyncClass, "getNativeHandle", "()J"); + + eglimageConstructor = _env->GetMethodID(eglimageClass, "", "(J)V"); + eglsyncConstructor = _env->GetMethodID(eglsyncClass, "", "(J)V"); + + jfieldID noImageFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_IMAGE", "Landroid/opengl/EGLImage;"); + _env->SetStaticObjectField(eglClass, noImageFieldID, eglNoImageObject); + + jfieldID noSyncFieldID = _env->GetStaticFieldID(eglClass, "EGL_NO_SYNC", "Landroid/opengl/EGLSync;"); + _env->SetStaticObjectField(eglClass, noSyncFieldID, eglNoSyncObject); +} + +static void * +getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining, jint *offset) +{ + jint position; + jint limit; + jint elementSizeShift; + jlong pointer; + + position = _env->GetIntField(buffer, positionID); + limit = _env->GetIntField(buffer, limitID); + elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); + *remaining = (limit - position) << elementSizeShift; + pointer = _env->CallStaticLongMethod(nioAccessClass, + getBasePointerID, buffer); + if (pointer != 0L) { + *array = NULL; + return reinterpret_cast(pointer); + } + eglimageGetHandleID = _env->GetMethodID(eglimageClass, "getNativeHandle", "()J"); + eglsyncGetHandleID = _env->GetMethodID(eglsyncClass, "getNativeHandle", "()J"); + + *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, + getBaseArrayID, buffer); + *offset = _env->CallStaticIntMethod(nioAccessClass, + getBaseArrayOffsetID, buffer); + + return NULL; +} + +static void +releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit) +{ + _env->ReleasePrimitiveArrayCritical(array, data, + commit ? 0 : JNI_ABORT); +} + +static void * +fromEGLHandle(JNIEnv *_env, jmethodID mid, jobject obj) { + if (obj == NULL){ + jniThrowException(_env, "java/lang/IllegalArgumentException", + "Object is set to null."); + } + + jlong handle = _env->CallLongMethod(obj, mid); + return reinterpret_cast(handle); +} + +static jobject +toEGLHandle(JNIEnv *_env, jclass cls, jmethodID con, void * handle) { + if (cls == eglimageClass && + (EGLImage)handle == EGL_NO_IMAGE) { + return eglNoImageObject; + } + + return _env->NewObject(cls, con, reinterpret_cast(handle)); +} + +// -------------------------------------------------------------------------- +/* EGLSync eglCreateSync ( EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list ) */ +static jobject +android_eglCreateSync + (JNIEnv *_env, jobject _this, jobject dpy, jint type, jlongArray attrib_list_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + EGLSync _returnValue = (EGLSync) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jint _remaining; + EGLAttrib *attrib_list = (EGLAttrib *) 0; + + if (!attrib_list_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "attrib_list == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(attrib_list_ref) - offset; + attrib_list_base = (EGLAttrib *) + _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); + attrib_list = attrib_list_base + offset; + + _returnValue = eglCreateSync( + (EGLDisplay)dpy_native, + (EGLenum)type, + (EGLAttrib *)attrib_list + ); + +exit: + if (attrib_list_base) { + _env->ReleaseLongArrayElements(attrib_list_ref, (jlong*)attrib_list_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return toEGLHandle(_env, eglsyncClass, eglsyncConstructor, _returnValue); +} + +/* EGLBoolean eglDestroySync ( EGLDisplay dpy, EGLSync sync ) */ +static jboolean +android_eglDestroySync + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync) { + EGLBoolean _returnValue = (EGLBoolean) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + + _returnValue = eglDestroySync( + (EGLDisplay)dpy_native, + (EGLSync)sync_native + ); + return (jboolean)_returnValue; +} + +/* EGLint eglClientWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout ) */ +static jint +android_eglClientWaitSync + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint flags, jlong timeout) { + EGLint _returnValue = (EGLint) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + + _returnValue = eglClientWaitSync( + (EGLDisplay)dpy_native, + (EGLSync)sync_native, + (EGLint)flags, + (EGLTime)timeout + ); + return (jint)_returnValue; +} + +/* EGLBoolean eglGetSyncAttrib ( EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value ) */ +static jboolean +android_eglGetSyncAttrib + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint attribute, jlongArray value_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + EGLBoolean _returnValue = (EGLBoolean) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + EGLAttrib *value_base = (EGLAttrib *) 0; + jint _remaining; + EGLAttrib *value = (EGLAttrib *) 0; + + if (!value_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "value == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(value_ref) - offset; + value_base = (EGLAttrib *) + _env->GetLongArrayElements(value_ref, (jboolean *)0); + value = value_base + offset; + + _returnValue = eglGetSyncAttrib( + (EGLDisplay)dpy_native, + (EGLSync)sync_native, + (EGLint)attribute, + (EGLAttrib *)value + ); + +exit: + if (value_base) { + _env->ReleaseLongArrayElements(value_ref, (jlong*)value_base, + _exception ? JNI_ABORT: 0); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return (jboolean)_returnValue; +} + +/* EGLDisplay eglGetPlatformDisplay ( EGLenum platform, EGLAttrib native_display, const EGLAttrib *attrib_list ) */ +static jobject +android_eglGetPlatformDisplay + (JNIEnv *_env, jobject _this, jint platform, jlong native_display, jlongArray attrib_list_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + EGLDisplay _returnValue = (EGLDisplay) 0; + EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jint _remaining; + EGLAttrib *attrib_list = (EGLAttrib *) 0; + + if (!attrib_list_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "attrib_list == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _remaining = _env->GetArrayLength(attrib_list_ref) - offset; + attrib_list_base = (EGLAttrib *) + _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); + attrib_list = attrib_list_base + offset; + + _returnValue = eglGetPlatformDisplay( + (EGLenum)platform, + (void *)native_display, + (EGLAttrib *)attrib_list + ); + +exit: + if (attrib_list_base) { + _env->ReleaseLongArrayElements(attrib_list_ref, (jlong*)attrib_list_base, + JNI_ABORT); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return toEGLHandle(_env, egldisplayClass, egldisplayConstructor, _returnValue); +} + +/* EGLSurface eglCreatePlatformWindowSurface ( EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list ) */ +static jobject +android_eglCreatePlatformWindowSurface + (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject native_window_buf, jlongArray attrib_list_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + EGLSurface _returnValue = (EGLSurface) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); + jint _native_windowRemaining; + void *native_window = (void *) 0; + EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jint _attrib_listRemaining; + EGLAttrib *attrib_list = (EGLAttrib *) 0; + + if (!native_window_buf) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "native_window == null"; + goto exit; + } + native_window = (void *)getPointer(_env, native_window_buf, (jarray*)&_array, &_native_windowRemaining, &_bufferOffset); + if (!attrib_list_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "attrib_list == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _attrib_listRemaining = _env->GetArrayLength(attrib_list_ref) - offset; + attrib_list_base = (EGLAttrib *) + _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); + attrib_list = attrib_list_base + offset; + + if (native_window == NULL) { + char * _native_windowBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + native_window = (void *) (_native_windowBase + _bufferOffset); + } + _returnValue = eglCreatePlatformWindowSurface( + (EGLDisplay)dpy_native, + (EGLConfig)config_native, + (void *)native_window, + (EGLAttrib *)attrib_list + ); + +exit: + if (attrib_list_base) { + _env->ReleaseLongArrayElements(attrib_list_ref, (jlong*)attrib_list_base, + JNI_ABORT); + } + if (_array) { + releasePointer(_env, _array, native_window, _exception ? JNI_FALSE : JNI_TRUE); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); +} + +/* EGLSurface eglCreatePlatformPixmapSurface ( EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list ) */ +static jobject +android_eglCreatePlatformPixmapSurface + (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject native_pixmap_buf, jlongArray attrib_list_ref, jint offset) { + jint _exception = 0; + const char * _exceptionType = NULL; + const char * _exceptionMessage = NULL; + jarray _array = (jarray) 0; + jint _bufferOffset = (jint) 0; + EGLSurface _returnValue = (EGLSurface) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); + jint _native_pixmapRemaining; + void *native_pixmap = (void *) 0; + EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jint _attrib_listRemaining; + EGLAttrib *attrib_list = (EGLAttrib *) 0; + + if (!native_pixmap_buf) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "native_pixmap == null"; + goto exit; + } + native_pixmap = (void *)getPointer(_env, native_pixmap_buf, (jarray*)&_array, &_native_pixmapRemaining, &_bufferOffset); + if (!attrib_list_ref) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "attrib_list == null"; + goto exit; + } + if (offset < 0) { + _exception = 1; + _exceptionType = "java/lang/IllegalArgumentException"; + _exceptionMessage = "offset < 0"; + goto exit; + } + _attrib_listRemaining = _env->GetArrayLength(attrib_list_ref) - offset; + attrib_list_base = (EGLAttrib *) + _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); + attrib_list = attrib_list_base + offset; + + if (native_pixmap == NULL) { + char * _native_pixmapBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); + native_pixmap = (void *) (_native_pixmapBase + _bufferOffset); + } + _returnValue = eglCreatePlatformPixmapSurface( + (EGLDisplay)dpy_native, + (EGLConfig)config_native, + (void *)native_pixmap, + (EGLAttrib *)attrib_list + ); + +exit: + if (attrib_list_base) { + _env->ReleaseLongArrayElements(attrib_list_ref, (jlong*)attrib_list_base, + JNI_ABORT); + } + if (_array) { + releasePointer(_env, _array, native_pixmap, _exception ? JNI_FALSE : JNI_TRUE); + } + if (_exception) { + jniThrowException(_env, _exceptionType, _exceptionMessage); + } + return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); +} + +/* EGLBoolean eglWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags ) */ +static jboolean +android_eglWaitSync + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint flags) { + EGLBoolean _returnValue = (EGLBoolean) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + + _returnValue = eglWaitSync( + (EGLDisplay)dpy_native, + (EGLSync)sync_native, + (EGLint)flags + ); + return (jboolean)_returnValue; +} + +static const char *classPathName = "android/opengl/EGL15"; + +static const JNINativeMethod methods[] = { +{"_nativeClassInit", "()V", (void*)nativeClassInit }, +{"eglCreateSync", "(Landroid/opengl/EGLDisplay;I[JI)Landroid/opengl/EGLSync;", (void *) android_eglCreateSync }, +{"eglDestroySync", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;)Z", (void *) android_eglDestroySync }, +{"eglClientWaitSync", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;IJ)I", (void *) android_eglClientWaitSync }, +{"eglGetSyncAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;I[JI)Z", (void *) android_eglGetSyncAttrib }, +{"eglGetPlatformDisplay", "(IJ[JI)Landroid/opengl/EGLDisplay;", (void *) android_eglGetPlatformDisplay }, +{"eglCreatePlatformWindowSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/nio/Buffer;[JI)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePlatformWindowSurface }, +{"eglCreatePlatformPixmapSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/nio/Buffer;[JI)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePlatformPixmapSurface }, +{"eglWaitSync", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;I)Z", (void *) android_eglWaitSync }, +}; + +int register_android_opengl_jni_EGL15(JNIEnv *_env) +{ + int err; + err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); + return err; +} diff --git a/opengl/java/android/opengl/EGL15.java b/opengl/java/android/opengl/EGL15.java new file mode 100644 index 000000000000..9aae6ad0f080 --- /dev/null +++ b/opengl/java/android/opengl/EGL15.java @@ -0,0 +1,149 @@ +/* +** Copyright 2018, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +package android.opengl; + +/** + * EGL 1.5 + * + */ +public class EGL15 { + + public static final int EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT = 0x00000001; + public static final int EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT = 0x00000002; + public static final int EGL_OPENGL_ES3_BIT = 0x00000040; + public static final int EGL_SYNC_FLUSH_COMMANDS_BIT = 0x0001; + public static final int EGL_GL_COLORSPACE_SRGB = 0x3089; + public static final int EGL_GL_COLORSPACE_LINEAR = 0x308A; + public static final int EGL_CONTEXT_MAJOR_VERSION = 0x3098; + public static final int EGL_CL_EVENT_HANDLE = 0x309C; + public static final int EGL_GL_COLORSPACE = 0x309D; + public static final int EGL_GL_TEXTURE_2D = 0x30B1; + public static final int EGL_GL_TEXTURE_3D = 0x30B2; + public static final int EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x30B3; + public static final int EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x30B4; + public static final int EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x30B5; + public static final int EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x30B6; + public static final int EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x30B7; + public static final int EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x30B8; + public static final int EGL_GL_RENDERBUFFER = 0x30B9; + public static final int EGL_GL_TEXTURE_LEVEL = 0x30BC; + public static final int EGL_GL_TEXTURE_ZOFFSET = 0x30BD; + public static final int EGL_IMAGE_PRESERVED = 0x30D2; + public static final int EGL_SYNC_PRIOR_COMMANDS_COMPLETE = 0x30F0; + public static final int EGL_SYNC_STATUS = 0x30F1; + public static final int EGL_SIGNALED = 0x30F2; + public static final int EGL_UNSIGNALED = 0x30F3; + public static final int EGL_TIMEOUT_EXPIRED = 0x30F5; + public static final int EGL_CONDITION_SATISFIED = 0x30F6; + public static final int EGL_SYNC_TYPE = 0x30F7; + public static final int EGL_SYNC_CONDITION = 0x30F8; + public static final int EGL_SYNC_FENCE = 0x30F9; + public static final int EGL_CONTEXT_MINOR_VERSION = 0x30FB; + public static final int EGL_CONTEXT_OPENGL_PROFILE_MASK = 0x30FD; + public static final int EGL_SYNC_CL_EVENT = 0x30FE; + public static final int EGL_SYNC_CL_EVENT_COMPLETE = 0x30FF; + public static final int EGL_CONTEXT_OPENGL_DEBUG = 0x31B0; + public static final int EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE = 0x31B1; + public static final int EGL_CONTEXT_OPENGL_ROBUST_ACCESS = 0x31B2; + public static final int EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY = 0x31BD; + public static final int EGL_NO_RESET_NOTIFICATION = 0x31BE; + public static final int EGL_LOSE_CONTEXT_ON_RESET = 0x31BF; + public static final int EGL_PLATFORM_ANDROID_KHR = 0x3141; + public static final long EGL_FOREVER = 0xFFFFFFFFFFFFFFFFL; + public static final EGLImage EGL_NO_IMAGE = null; + public static final EGLSync EGL_NO_SYNC = null; + public static final EGLContext EGL_NO_CONTEXT = null; + public static final EGLDisplay EGL_NO_DISPLAY = null; + public static final EGLSurface EGL_NO_SURFACE = null; + + native private static void _nativeClassInit(); + static { + _nativeClassInit(); + } + // C function EGLSync eglCreateSync ( EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list ) + + public static native EGLSync eglCreateSync( + EGLDisplay dpy, + int type, + long[] attrib_list, + int offset + ); + + // C function EGLBoolean eglDestroySync ( EGLDisplay dpy, EGLSync sync ) + + public static native boolean eglDestroySync( + EGLDisplay dpy, + EGLSync sync + ); + + // C function EGLint eglClientWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout ) + + public static native int eglClientWaitSync( + EGLDisplay dpy, + EGLSync sync, + int flags, + long timeout + ); + + // C function EGLBoolean eglGetSyncAttrib ( EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value ) + + public static native boolean eglGetSyncAttrib( + EGLDisplay dpy, + EGLSync sync, + int attribute, + long[] value, + int offset + ); + + // C function EGLDisplay eglGetPlatformDisplay ( EGLenum platform, EGLAttrib native_display, const EGLAttrib *attrib_list ) + + public static native EGLDisplay eglGetPlatformDisplay( + int platform, + long native_display, + long[] attrib_list, + int offset + ); + + // C function EGLSurface eglCreatePlatformWindowSurface ( EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list ) + + public static native EGLSurface eglCreatePlatformWindowSurface( + EGLDisplay dpy, + EGLConfig config, + java.nio.Buffer native_window, + long[] attrib_list, + int offset + ); + + // C function EGLSurface eglCreatePlatformPixmapSurface ( EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list ) + + public static native EGLSurface eglCreatePlatformPixmapSurface( + EGLDisplay dpy, + EGLConfig config, + java.nio.Buffer native_pixmap, + long[] attrib_list, + int offset + ); + + // C function EGLBoolean eglWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags ) + + public static native boolean eglWaitSync( + EGLDisplay dpy, + EGLSync sync, + int flags + ); + +} diff --git a/opengl/java/android/opengl/EGLImage.java b/opengl/java/android/opengl/EGLImage.java new file mode 100644 index 000000000000..731ce72aa043 --- /dev/null +++ b/opengl/java/android/opengl/EGLImage.java @@ -0,0 +1,37 @@ +/* +** +** Copyright 2018, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +package android.opengl; + +/** + * Wrapper class for native EGLImage objects. + * + */ +public class EGLImage extends EGLObjectHandle { + private EGLImage(long handle) { + super(handle); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof EGLImage)) return false; + + EGLImage that = (EGLImage) o; + return getNativeHandle() == that.getNativeHandle(); + } +} diff --git a/opengl/java/android/opengl/EGLSync.java b/opengl/java/android/opengl/EGLSync.java new file mode 100644 index 000000000000..472f9e71254f --- /dev/null +++ b/opengl/java/android/opengl/EGLSync.java @@ -0,0 +1,37 @@ +/* +** +** Copyright 2018, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +package android.opengl; + +/** + * Wrapper class for native EGLSync objects. + * + */ +public class EGLSync extends EGLObjectHandle { + private EGLSync(long handle) { + super(handle); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof EGLSync)) return false; + + EGLSync that = (EGLSync) o; + return getNativeHandle() == that.getNativeHandle(); + } +} -- cgit v1.2.3-59-g8ed1b From 6e8c60ccc1bbfb4da31ef4d1055d938cb2d430af Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Fri, 19 Oct 2018 11:19:53 -0600 Subject: Add EGL15: eglCreateImage, eglDestroyImage Also change eglCreatePlatformPixmapSurface to throw an unsupported extension rather than call the native function which will return an error indicating it's unsupported. Bug: 80297325 Test: atest CtsGraphicsTestCases:EGL15Test Change-Id: I94f2d39678515fdacf9b2fccd1c531365930ad1b --- api/current.txt | 2 + core/jni/android_opengl_EGL15.cpp | 75 ++++++++++++++++++++--------------- opengl/java/android/opengl/EGL15.java | 18 +++++++++ 3 files changed, 62 insertions(+), 33 deletions(-) (limited to 'opengl/java') diff --git a/api/current.txt b/api/current.txt index 51df940866d3..1c3ee82dbba0 100755 --- a/api/current.txt +++ b/api/current.txt @@ -29745,9 +29745,11 @@ package android.opengl { public class EGL15 { ctor public EGL15(); method public static int eglClientWaitSync(android.opengl.EGLDisplay, android.opengl.EGLSync, int, long); + method public static android.opengl.EGLImage eglCreateImage(android.opengl.EGLDisplay, android.opengl.EGLContext, int, long, long[], int); method public static android.opengl.EGLSurface eglCreatePlatformPixmapSurface(android.opengl.EGLDisplay, android.opengl.EGLConfig, java.nio.Buffer, long[], int); method public static android.opengl.EGLSurface eglCreatePlatformWindowSurface(android.opengl.EGLDisplay, android.opengl.EGLConfig, java.nio.Buffer, long[], int); method public static android.opengl.EGLSync eglCreateSync(android.opengl.EGLDisplay, int, long[], int); + method public static boolean eglDestroyImage(android.opengl.EGLDisplay, android.opengl.EGLImage); method public static boolean eglDestroySync(android.opengl.EGLDisplay, android.opengl.EGLSync); method public static android.opengl.EGLDisplay eglGetPlatformDisplay(int, long, long[], int); method public static boolean eglGetSyncAttrib(android.opengl.EGLDisplay, android.opengl.EGLSync, int, long[], int); diff --git a/core/jni/android_opengl_EGL15.cpp b/core/jni/android_opengl_EGL15.cpp index 4a30babafa49..b52f137da7d6 100644 --- a/core/jni/android_opengl_EGL15.cpp +++ b/core/jni/android_opengl_EGL15.cpp @@ -456,27 +456,41 @@ exit: static jobject android_eglCreatePlatformPixmapSurface (JNIEnv *_env, jobject _this, jobject dpy, jobject config, jobject native_pixmap_buf, jlongArray attrib_list_ref, jint offset) { + jniThrowException(_env, "java/lang/UnsupportedOperationException", + "eglCreatePlatformPixmapSurface"); + return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, (EGLSurface) 0); +} + +/* EGLBoolean eglWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags ) */ +static jboolean +android_eglWaitSync + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint flags) { + EGLBoolean _returnValue = (EGLBoolean) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + + _returnValue = eglWaitSync( + (EGLDisplay)dpy_native, + (EGLSync)sync_native, + (EGLint)flags + ); + return (jboolean)_returnValue; +} + +/* EGLImage eglCreateImage ( EGLDisplay dpy, EGLContext context, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list ) */ +static jobject +android_eglCreateImage + (JNIEnv *_env, jobject _this, jobject dpy, jobject context, jint target, jlong buffer, jlongArray attrib_list_ref, jint offset) { jint _exception = 0; const char * _exceptionType = NULL; const char * _exceptionMessage = NULL; - jarray _array = (jarray) 0; - jint _bufferOffset = (jint) 0; - EGLSurface _returnValue = (EGLSurface) 0; + EGLImage _returnValue = (EGLImage) 0; EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); - EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); - jint _native_pixmapRemaining; - void *native_pixmap = (void *) 0; + EGLContext context_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, context); EGLAttrib *attrib_list_base = (EGLAttrib *) 0; - jint _attrib_listRemaining; + jint _remaining; EGLAttrib *attrib_list = (EGLAttrib *) 0; - if (!native_pixmap_buf) { - _exception = 1; - _exceptionType = "java/lang/IllegalArgumentException"; - _exceptionMessage = "native_pixmap == null"; - goto exit; - } - native_pixmap = (void *)getPointer(_env, native_pixmap_buf, (jarray*)&_array, &_native_pixmapRemaining, &_bufferOffset); if (!attrib_list_ref) { _exception = 1; _exceptionType = "java/lang/IllegalArgumentException"; @@ -489,19 +503,16 @@ android_eglCreatePlatformPixmapSurface _exceptionMessage = "offset < 0"; goto exit; } - _attrib_listRemaining = _env->GetArrayLength(attrib_list_ref) - offset; + _remaining = _env->GetArrayLength(attrib_list_ref) - offset; attrib_list_base = (EGLAttrib *) _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); attrib_list = attrib_list_base + offset; - if (native_pixmap == NULL) { - char * _native_pixmapBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); - native_pixmap = (void *) (_native_pixmapBase + _bufferOffset); - } - _returnValue = eglCreatePlatformPixmapSurface( + _returnValue = eglCreateImage( (EGLDisplay)dpy_native, - (EGLConfig)config_native, - (void *)native_pixmap, + (EGLContext)context_native, + (EGLenum)target, + (EGLClientBuffer)buffer, (EGLAttrib *)attrib_list ); @@ -510,27 +521,23 @@ exit: _env->ReleaseLongArrayElements(attrib_list_ref, (jlong*)attrib_list_base, JNI_ABORT); } - if (_array) { - releasePointer(_env, _array, native_pixmap, _exception ? JNI_FALSE : JNI_TRUE); - } if (_exception) { jniThrowException(_env, _exceptionType, _exceptionMessage); } - return toEGLHandle(_env, eglsurfaceClass, eglsurfaceConstructor, _returnValue); + return toEGLHandle(_env, eglimageClass, eglimageConstructor, _returnValue); } -/* EGLBoolean eglWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags ) */ +/* EGLBoolean eglDestroyImage ( EGLDisplay dpy, EGLImage image ) */ static jboolean -android_eglWaitSync - (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint flags) { +android_eglDestroyImage + (JNIEnv *_env, jobject _this, jobject dpy, jobject image) { EGLBoolean _returnValue = (EGLBoolean) 0; EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); - EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + EGLImage image_native = (EGLImage) fromEGLHandle(_env, eglimageGetHandleID, image); - _returnValue = eglWaitSync( + _returnValue = eglDestroyImage( (EGLDisplay)dpy_native, - (EGLSync)sync_native, - (EGLint)flags + (EGLImage)image_native ); return (jboolean)_returnValue; } @@ -547,6 +554,8 @@ static const JNINativeMethod methods[] = { {"eglCreatePlatformWindowSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/nio/Buffer;[JI)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePlatformWindowSurface }, {"eglCreatePlatformPixmapSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/nio/Buffer;[JI)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePlatformPixmapSurface }, {"eglWaitSync", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;I)Z", (void *) android_eglWaitSync }, +{"eglCreateImage", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLContext;IJ[JI)Landroid/opengl/EGLImage;", (void *) android_eglCreateImage }, +{"eglDestroyImage", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLImage;)Z", (void *) android_eglDestroyImage }, }; int register_android_opengl_jni_EGL15(JNIEnv *_env) diff --git a/opengl/java/android/opengl/EGL15.java b/opengl/java/android/opengl/EGL15.java index 9aae6ad0f080..f855fe2591e1 100644 --- a/opengl/java/android/opengl/EGL15.java +++ b/opengl/java/android/opengl/EGL15.java @@ -146,4 +146,22 @@ public class EGL15 { int flags ); + // C function EGLImage eglCreateImage ( EGLDisplay dpy, EGLContext context, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list ) + + public static native EGLImage eglCreateImage( + EGLDisplay dpy, + EGLContext context, + int target, + long buffer, + long[] attrib_list, + int offset + ); + + // C function EGLBoolean eglDestroyImage ( EGLDisplay dpy, EGLImage image ) + + public static native boolean eglDestroyImage( + EGLDisplay dpy, + EGLImage image + ); + } -- cgit v1.2.3-59-g8ed1b From 986992f2cde4dfde5c574e7739b17093047ae5b9 Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Wed, 24 Oct 2018 09:10:32 -0600 Subject: Make EGL15 class final Updates from API review feedback. Bug: 118296391 Test: manually inspect code Change-Id: If79f03497e77dfce65909a734bafbb6e08c39155 --- api/current.txt | 3 +-- opengl/java/android/opengl/EGL15.java | 4 +++- 2 files changed, 4 insertions(+), 3 deletions(-) (limited to 'opengl/java') diff --git a/api/current.txt b/api/current.txt index 1c3ee82dbba0..b6427919f45f 100755 --- a/api/current.txt +++ b/api/current.txt @@ -29742,8 +29742,7 @@ package android.opengl { field public static final int EGL_WINDOW_BIT = 4; // 0x4 } - public class EGL15 { - ctor public EGL15(); + public final class EGL15 { method public static int eglClientWaitSync(android.opengl.EGLDisplay, android.opengl.EGLSync, int, long); method public static android.opengl.EGLImage eglCreateImage(android.opengl.EGLDisplay, android.opengl.EGLContext, int, long, long[], int); method public static android.opengl.EGLSurface eglCreatePlatformPixmapSurface(android.opengl.EGLDisplay, android.opengl.EGLConfig, java.nio.Buffer, long[], int); diff --git a/opengl/java/android/opengl/EGL15.java b/opengl/java/android/opengl/EGL15.java index f855fe2591e1..bd845e7ec1a0 100644 --- a/opengl/java/android/opengl/EGL15.java +++ b/opengl/java/android/opengl/EGL15.java @@ -20,7 +20,9 @@ package android.opengl; * EGL 1.5 * */ -public class EGL15 { +public final class EGL15 { + + private EGL15() {}; public static final int EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT = 0x00000001; public static final int EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT = 0x00000002; -- cgit v1.2.3-59-g8ed1b From 71fae62f5fe03e9f8453ac3880587567ffcf9be6 Mon Sep 17 00:00:00 2001 From: Leon Scroggins III Date: Tue, 26 Mar 2019 16:28:41 -0400 Subject: Pass Bitmap's native instance to JNI where feasible Test: CtsGraphicsTestCases, CtsUiRenderingTestCases, CtsRenderscriptTestCases This is significantly faster than passing the Java object down and then calling a JNI method to retrieve the pointer. See https://buganizer.corp.google.com/issues/16656908#comment19 In some cases this changes what used to be native crashes (due to android::BitmapWrapper:assertValid's LOG_ALWAYS_FATAL_IF) into NullPointerExceptions (if a caller used a null Bitmap). In addition: - Remove unnecessary JNIEnv param from toBitmap(jlong) - Change instances of toBitmap(JNIEnv*, jobject) to the above - Replace calls to GraphicsJNI::getSkBitmap() to inline calls to toBitmap/getSkBitmap - make Canvas#nInitRaster @FastNative (FIXME: Could these be @CriticalNative?) Change-Id: I6194097be1b6e6952eba70e1e7052a5a250eed93 --- core/jni/android/graphics/Bitmap.cpp | 3 +- core/jni/android/graphics/Bitmap.h | 2 +- core/jni/android/graphics/BitmapFactory.cpp | 35 +++++++++--------- core/jni/android/graphics/BitmapRegionDecoder.cpp | 9 ++--- core/jni/android/graphics/NinePatch.cpp | 6 ++-- core/jni/android/graphics/Shader.cpp | 8 ++--- core/jni/android/graphics/pdf/PdfRenderer.cpp | 6 ++-- core/jni/android/opengl/util.cpp | 24 ++++++------- core/jni/android_graphics_Canvas.cpp | 42 +++++++++++----------- core/jni/android_view_ThreadedRenderer.cpp | 12 +++---- graphics/java/android/graphics/BaseCanvas.java | 21 +++++------ .../java/android/graphics/BaseRecordingCanvas.java | 21 +++++------ graphics/java/android/graphics/BitmapFactory.java | 25 ++++++++++--- .../java/android/graphics/BitmapRegionDecoder.java | 4 ++- graphics/java/android/graphics/BitmapShader.java | 4 +-- graphics/java/android/graphics/Canvas.java | 14 ++++---- .../java/android/graphics/HardwareRenderer.java | 12 +++---- graphics/java/android/graphics/NinePatch.java | 6 ++-- .../java/android/graphics/pdf/PdfRenderer.java | 7 ++-- opengl/java/android/opengl/GLUtils.java | 26 ++++++++------ rs/java/android/renderscript/RenderScript.java | 38 ++++++++++++-------- rs/jni/android_renderscript_RenderScript.cpp | 32 ++++++++--------- 22 files changed, 198 insertions(+), 159 deletions(-) (limited to 'opengl/java') diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp index 59cc5ec55206..a4e37093def0 100755 --- a/core/jni/android/graphics/Bitmap.cpp +++ b/core/jni/android/graphics/Bitmap.cpp @@ -230,8 +230,7 @@ Bitmap& toBitmap(JNIEnv* env, jobject bitmap) { return localBitmap->bitmap(); } -Bitmap& toBitmap(JNIEnv* env, jlong bitmapHandle) { - SkASSERT(env); +Bitmap& toBitmap(jlong bitmapHandle) { LocalScopedBitmap localBitmap(bitmapHandle); return localBitmap->bitmap(); } diff --git a/core/jni/android/graphics/Bitmap.h b/core/jni/android/graphics/Bitmap.h index 8cfef196db1b..6934d26cdc78 100644 --- a/core/jni/android/graphics/Bitmap.h +++ b/core/jni/android/graphics/Bitmap.h @@ -41,7 +41,7 @@ jobject createBitmap(JNIEnv* env, Bitmap* bitmap, void toSkBitmap(jlong bitmapHandle, SkBitmap* outBitmap); Bitmap& toBitmap(JNIEnv* env, jobject bitmap); -Bitmap& toBitmap(JNIEnv* env, jlong bitmapHandle); +Bitmap& toBitmap(jlong bitmapHandle); // NDK access void imageInfo(JNIEnv* env, jobject bitmap, AndroidBitmapInfo* info); diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp index f510e24c9507..3f05c3b57c69 100644 --- a/core/jni/android/graphics/BitmapFactory.cpp +++ b/core/jni/android/graphics/BitmapFactory.cpp @@ -180,7 +180,8 @@ static bool needsFineScale(const SkISize fullSize, const SkISize decodedSize, } static jobject doDecode(JNIEnv* env, std::unique_ptr stream, - jobject padding, jobject options, jlong colorSpaceHandle) { + jobject padding, jobject options, jlong inBitmapHandle, + jlong colorSpaceHandle) { // Set default values for the options parameters. int sampleSize = 1; bool onlyDecodeSize = false; @@ -323,8 +324,8 @@ static jobject doDecode(JNIEnv* env, std::unique_ptr stream, android::Bitmap* reuseBitmap = nullptr; unsigned int existingBufferSize = 0; - if (javaBitmap != NULL) { - reuseBitmap = &bitmap::toBitmap(env, javaBitmap); + if (javaBitmap != nullptr) { + reuseBitmap = &bitmap::toBitmap(inBitmapHandle); if (reuseBitmap->isImmutable()) { ALOGW("Unable to reuse an immutable bitmap as an image decoder target."); javaBitmap = nullptr; @@ -513,7 +514,7 @@ static jobject doDecode(JNIEnv* env, std::unique_ptr stream, } static jobject nativeDecodeStream(JNIEnv* env, jobject clazz, jobject is, jbyteArray storage, - jobject padding, jobject options, jlong colorSpaceHandle) { + jobject padding, jobject options, jlong inBitmapHandle, jlong colorSpaceHandle) { jobject bitmap = NULL; std::unique_ptr stream(CreateJavaInputStreamAdaptor(env, is, storage)); @@ -522,13 +523,14 @@ static jobject nativeDecodeStream(JNIEnv* env, jobject clazz, jobject is, jbyteA std::unique_ptr bufferedStream( SkFrontBufferedStream::Make(std::move(stream), SkCodec::MinBufferedBytesNeeded())); SkASSERT(bufferedStream.get() != NULL); - bitmap = doDecode(env, std::move(bufferedStream), padding, options, colorSpaceHandle); + bitmap = doDecode(env, std::move(bufferedStream), padding, options, inBitmapHandle, + colorSpaceHandle); } return bitmap; } static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, jobject fileDescriptor, - jobject padding, jobject bitmapFactoryOptions, jlong colorSpaceHandle) { + jobject padding, jobject bitmapFactoryOptions, jlong inBitmapHandle, jlong colorSpaceHandle) { NPE_CHECK_RETURN_ZERO(env, fileDescriptor); @@ -565,7 +567,7 @@ static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, jobject fi if (::lseek(descriptor, 0, SEEK_CUR) == 0) { assert(isSeekable(dupDescriptor)); return doDecode(env, std::move(fileStream), padding, bitmapFactoryOptions, - colorSpaceHandle); + inBitmapHandle, colorSpaceHandle); } // Use a buffered stream. Although an SkFILEStream can be rewound, this @@ -574,25 +576,26 @@ static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, jobject fi std::unique_ptr stream(SkFrontBufferedStream::Make(std::move(fileStream), SkCodec::MinBufferedBytesNeeded())); - return doDecode(env, std::move(stream), padding, bitmapFactoryOptions, colorSpaceHandle); + return doDecode(env, std::move(stream), padding, bitmapFactoryOptions, inBitmapHandle, + colorSpaceHandle); } static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, jlong native_asset, - jobject padding, jobject options, jlong colorSpaceHandle) { + jobject padding, jobject options, jlong inBitmapHandle, jlong colorSpaceHandle) { Asset* asset = reinterpret_cast(native_asset); // since we know we'll be done with the asset when we return, we can // just use a simple wrapper return doDecode(env, skstd::make_unique(asset), padding, options, - colorSpaceHandle); + inBitmapHandle, colorSpaceHandle); } static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray, - jint offset, jint length, jobject options, jlong colorSpaceHandle) { + jint offset, jint length, jobject options, jlong inBitmapHandle, jlong colorSpaceHandle) { AutoJavaByteArray ar(env, byteArray); return doDecode(env, skstd::make_unique(ar.ptr() + offset, length, false), - nullptr, options, colorSpaceHandle); + nullptr, options, inBitmapHandle, colorSpaceHandle); } static jboolean nativeIsSeekable(JNIEnv* env, jobject, jobject fileDescriptor) { @@ -604,22 +607,22 @@ static jboolean nativeIsSeekable(JNIEnv* env, jobject, jobject fileDescriptor) { static const JNINativeMethod gMethods[] = { { "nativeDecodeStream", - "(Ljava/io/InputStream;[BLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;", + "(Ljava/io/InputStream;[BLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;", (void*)nativeDecodeStream }, { "nativeDecodeFileDescriptor", - "(Ljava/io/FileDescriptor;Landroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;", + "(Ljava/io/FileDescriptor;Landroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;", (void*)nativeDecodeFileDescriptor }, { "nativeDecodeAsset", - "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;", + "(JLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;", (void*)nativeDecodeAsset }, { "nativeDecodeByteArray", - "([BIILandroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;", + "([BIILandroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;", (void*)nativeDecodeByteArray }, diff --git a/core/jni/android/graphics/BitmapRegionDecoder.cpp b/core/jni/android/graphics/BitmapRegionDecoder.cpp index 8a632a14ee04..6ffa72ad8903 100644 --- a/core/jni/android/graphics/BitmapRegionDecoder.cpp +++ b/core/jni/android/graphics/BitmapRegionDecoder.cpp @@ -125,13 +125,14 @@ static jobject nativeNewInstanceFromAsset(JNIEnv* env, jobject clazz, * reportSizeToVM not supported */ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint inputX, - jint inputY, jint inputWidth, jint inputHeight, jobject options, jlong colorSpaceHandle) { + jint inputY, jint inputWidth, jint inputHeight, jobject options, jlong inBitmapHandle, + jlong colorSpaceHandle) { // Set default options. int sampleSize = 1; SkColorType colorType = kN32_SkColorType; bool requireUnpremul = false; - jobject javaBitmap = NULL; + jobject javaBitmap = nullptr; bool isHardware = false; sk_sp colorSpace = GraphicsJNI::getNativeColorSpace(colorSpaceHandle); // Update the default options with any options supplied by the client. @@ -158,7 +159,7 @@ static jobject nativeDecodeRegion(JNIEnv* env, jobject, jlong brdHandle, jint in android::Bitmap* recycledBitmap = nullptr; size_t recycledBytes = 0; if (javaBitmap) { - recycledBitmap = &bitmap::toBitmap(env, javaBitmap); + recycledBitmap = &bitmap::toBitmap(inBitmapHandle); if (recycledBitmap->isImmutable()) { ALOGW("Warning: Reusing an immutable bitmap as an image decoder target."); } @@ -258,7 +259,7 @@ static void nativeClean(JNIEnv* env, jobject, jlong brdHandle) { static const JNINativeMethod gBitmapRegionDecoderMethods[] = { { "nativeDecodeRegion", - "(JIIIILandroid/graphics/BitmapFactory$Options;J)Landroid/graphics/Bitmap;", + "(JIIIILandroid/graphics/BitmapFactory$Options;JJ)Landroid/graphics/Bitmap;", (void*)nativeDecodeRegion}, { "nativeGetHeight", "(J)I", (void*)nativeGetHeight}, diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp index bb291e74ce0d..15f951688d43 100644 --- a/core/jni/android/graphics/NinePatch.cpp +++ b/core/jni/android/graphics/NinePatch.cpp @@ -84,13 +84,13 @@ public: delete[] patch; } - static jlong getTransparentRegion(JNIEnv* env, jobject, jobject jbitmap, + static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapPtr, jlong chunkHandle, jobject dstRect) { Res_png_9patch* chunk = reinterpret_cast(chunkHandle); SkASSERT(chunk); SkBitmap bitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); SkRect dst; GraphicsJNI::jrect_to_rect(env, dstRect, &dst); @@ -156,7 +156,7 @@ static const JNINativeMethod gNinePatchMethods[] = { { "validateNinePatchChunk", "([B)J", (void*) SkNinePatchGlue::validateNinePatchChunk }, { "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize }, - { "nativeGetTransparentRegion", "(Landroid/graphics/Bitmap;JLandroid/graphics/Rect;)J", + { "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J", (void*) SkNinePatchGlue::getTransparentRegion } }; diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp index 298f7f8f78e5..44d2cac8739d 100644 --- a/core/jni/android/graphics/Shader.cpp +++ b/core/jni/android/graphics/Shader.cpp @@ -62,14 +62,14 @@ static jlong Shader_getNativeFinalizer(JNIEnv*, jobject) { /////////////////////////////////////////////////////////////////////////////////////////////// -static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jobject jbitmap, +static jlong BitmapShader_constructor(JNIEnv* env, jobject o, jlong matrixPtr, jlong bitmapHandle, jint tileModeX, jint tileModeY) { const SkMatrix* matrix = reinterpret_cast(matrixPtr); sk_sp image; - if (jbitmap) { + if (bitmapHandle) { // Only pass a valid SkBitmap object to the constructor if the Bitmap exists. Otherwise, // we'll pass an empty SkBitmap to avoid crashing/excepting for compatibility. - image = android::bitmap::toBitmap(env, jbitmap).makeImage(); + image = android::bitmap::toBitmap(bitmapHandle).makeImage(); } if (!image.get()) { @@ -222,7 +222,7 @@ static const JNINativeMethod gShaderMethods[] = { }; static const JNINativeMethod gBitmapShaderMethods[] = { - { "nativeCreate", "(JLandroid/graphics/Bitmap;II)J", (void*)BitmapShader_constructor }, + { "nativeCreate", "(JJII)J", (void*)BitmapShader_constructor }, }; static const JNINativeMethod gLinearGradientMethods[] = { diff --git a/core/jni/android/graphics/pdf/PdfRenderer.cpp b/core/jni/android/graphics/pdf/PdfRenderer.cpp index 32ac30fdabb0..761830b0e97c 100644 --- a/core/jni/android/graphics/pdf/PdfRenderer.cpp +++ b/core/jni/android/graphics/pdf/PdfRenderer.cpp @@ -73,12 +73,12 @@ static void nativeClosePage(JNIEnv* env, jclass thiz, jlong pagePtr) { } static void nativeRenderPage(JNIEnv* env, jclass thiz, jlong documentPtr, jlong pagePtr, - jobject jbitmap, jint clipLeft, jint clipTop, jint clipRight, jint clipBottom, + jlong bitmapPtr, jint clipLeft, jint clipTop, jint clipRight, jint clipBottom, jlong transformPtr, jint renderMode) { FPDF_PAGE page = reinterpret_cast(pagePtr); SkBitmap skBitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &skBitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&skBitmap); const int stride = skBitmap.width() * 4; @@ -117,7 +117,7 @@ static const JNINativeMethod gPdfRenderer_Methods[] = { {"nativeClose", "(J)V", (void*) nativeClose}, {"nativeGetPageCount", "(J)I", (void*) nativeGetPageCount}, {"nativeScaleForPrinting", "(J)Z", (void*) nativeScaleForPrinting}, - {"nativeRenderPage", "(JJLandroid/graphics/Bitmap;IIIIJI)V", (void*) nativeRenderPage}, + {"nativeRenderPage", "(JJJIIIIJI)V", (void*) nativeRenderPage}, {"nativeOpenPageAndGetSize", "(JILandroid/graphics/Point;)J", (void*) nativeOpenPageAndGetSize}, {"nativeClosePage", "(J)V", (void*) nativeClosePage} }; diff --git a/core/jni/android/opengl/util.cpp b/core/jni/android/opengl/util.cpp index d50e60c1a899..09f0e8e232bf 100644 --- a/core/jni/android/opengl/util.cpp +++ b/core/jni/android/opengl/util.cpp @@ -703,27 +703,27 @@ static int getType(SkColorType colorType) } static jint util_getInternalFormat(JNIEnv *env, jclass clazz, - jobject jbitmap) + jlong bitmapPtr) { SkBitmap nativeBitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &nativeBitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&nativeBitmap); return getInternalFormat(nativeBitmap.colorType()); } static jint util_getType(JNIEnv *env, jclass clazz, - jobject jbitmap) + jlong bitmapPtr) { SkBitmap nativeBitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &nativeBitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&nativeBitmap); return getType(nativeBitmap.colorType()); } static jint util_texImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint internalformat, - jobject jbitmap, jint type, jint border) + jlong bitmapPtr, jint type, jint border) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); SkColorType colorType = bitmap.colorType(); if (internalformat < 0) { internalformat = getInternalFormat(colorType); @@ -748,10 +748,10 @@ static jint util_texImage2D(JNIEnv *env, jclass clazz, static jint util_texSubImage2D(JNIEnv *env, jclass clazz, jint target, jint level, jint xoffset, jint yoffset, - jobject jbitmap, jint format, jint type) + jlong bitmapPtr, jint format, jint type) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); SkColorType colorType = bitmap.colorType(); int internalFormat = getInternalFormat(colorType); if (format < 0) { @@ -1068,10 +1068,10 @@ static const JNINativeMethod gVisibilityMethods[] = { }; static const JNINativeMethod gUtilsMethods[] = { - { "native_getInternalFormat", "(Landroid/graphics/Bitmap;)I", (void*) util_getInternalFormat }, - { "native_getType", "(Landroid/graphics/Bitmap;)I", (void*) util_getType }, - { "native_texImage2D", "(IIILandroid/graphics/Bitmap;II)I", (void*)util_texImage2D }, - { "native_texSubImage2D", "(IIIILandroid/graphics/Bitmap;II)I", (void*)util_texSubImage2D }, + { "native_getInternalFormat", "(J)I", (void*) util_getInternalFormat }, + { "native_getType", "(J)I", (void*) util_getType }, + { "native_texImage2D", "(IIIJII)I", (void*)util_texImage2D }, + { "native_texSubImage2D", "(IIIIJII)I", (void*)util_texSubImage2D }, }; static const JNINativeMethod gEtc1Methods[] = { diff --git a/core/jni/android_graphics_Canvas.cpp b/core/jni/android_graphics_Canvas.cpp index 9c48c33dc2ed..7a8c5c8a7b36 100644 --- a/core/jni/android_graphics_Canvas.cpp +++ b/core/jni/android_graphics_Canvas.cpp @@ -54,20 +54,20 @@ static jlong getNativeFinalizer(JNIEnv* env, jobject clazz) { } // Native wrapper constructor used by Canvas(Bitmap) -static jlong initRaster(JNIEnv* env, jobject, jobject jbitmap) { +static jlong initRaster(JNIEnv* env, jobject, jlong bitmapHandle) { SkBitmap bitmap; - if (jbitmap != NULL) { - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + if (bitmapHandle != 0) { + bitmap::toBitmap(bitmapHandle).getSkBitmap(&bitmap); } return reinterpret_cast(Canvas::create_canvas(bitmap)); } // Set the given bitmap as the new draw target (wrapped in a new SkCanvas), // optionally copying canvas matrix & clip state. -static void setBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap) { +static void setBitmap(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle) { SkBitmap bitmap; - if (jbitmap != NULL) { - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + if (bitmapHandle != 0) { + bitmap::toBitmap(bitmapHandle).getSkBitmap(&bitmap); } get_canvas(canvasHandle)->setBitmap(bitmap); } @@ -397,7 +397,7 @@ static void drawNinePatch(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmap jlong paintHandle, jint dstDensity, jint srcDensity) { Canvas* canvas = get_canvas(canvasHandle); - Bitmap& bitmap = android::bitmap::toBitmap(env, bitmapHandle); + Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle); const android::Res_png_9patch* chunk = reinterpret_cast(chunkHandle); const Paint* paint = reinterpret_cast(paintHandle); @@ -423,11 +423,11 @@ static void drawNinePatch(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmap } } -static void drawBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap, +static void drawBitmap(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, jfloat left, jfloat top, jlong paintHandle, jint canvasDensity, jint screenDensity, jint bitmapDensity) { Canvas* canvas = get_canvas(canvasHandle); - Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap); + Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle); const Paint* paint = reinterpret_cast(paintHandle); if (canvasDensity == bitmapDensity || canvasDensity == 0 || bitmapDensity == 0) { @@ -458,22 +458,22 @@ static void drawBitmap(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap } } -static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap, +static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, jlong matrixHandle, jlong paintHandle) { const SkMatrix* matrix = reinterpret_cast(matrixHandle); const Paint* paint = reinterpret_cast(paintHandle); - Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap); + Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle); get_canvas(canvasHandle)->drawBitmap(bitmap, *matrix, paint); } -static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap, +static void drawBitmapRect(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, float srcLeft, float srcTop, float srcRight, float srcBottom, float dstLeft, float dstTop, float dstRight, float dstBottom, jlong paintHandle, jint screenDensity, jint bitmapDensity) { Canvas* canvas = get_canvas(canvasHandle); const Paint* paint = reinterpret_cast(paintHandle); - Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap); + Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle); if (screenDensity != 0 && screenDensity != bitmapDensity) { Paint filteredPaint; if (paint) { @@ -512,7 +512,7 @@ static void drawBitmapArray(JNIEnv* env, jobject, jlong canvasHandle, get_canvas(canvasHandle)->drawBitmap(*androidBitmap, x, y, paint); } -static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap, +static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle, jint meshWidth, jint meshHeight, jfloatArray jverts, jint vertIndex, jintArray jcolors, jint colorIndex, jlong paintHandle) { if (Canvas::GetApiLevel() < __ANDROID_API_P__) { @@ -527,7 +527,7 @@ static void drawBitmapMesh(JNIEnv* env, jobject, jlong canvasHandle, jobject jbi AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); const Paint* paint = reinterpret_cast(paintHandle); - Bitmap& bitmap = android::bitmap::toBitmap(env, jbitmap); + Bitmap& bitmap = android::bitmap::toBitmap(bitmapHandle); get_canvas(canvasHandle)->drawBitmapMesh(bitmap, meshWidth, meshHeight, vertA.ptr() + vertIndex*2, colorA.ptr() + colorIndex, paint); @@ -651,13 +651,13 @@ static void setCompatibilityVersion(JNIEnv* env, jobject, jint apiLevel) { static const JNINativeMethod gMethods[] = { {"nGetNativeFinalizer", "()J", (void*) CanvasJNI::getNativeFinalizer}, - {"nInitRaster", "(Landroid/graphics/Bitmap;)J", (void*) CanvasJNI::initRaster}, {"nFreeCaches", "()V", (void*) CanvasJNI::freeCaches}, {"nFreeTextLayoutCaches", "()V", (void*) CanvasJNI::freeTextLayoutCaches}, {"nSetCompatibilityVersion", "(I)V", (void*) CanvasJNI::setCompatibilityVersion}, // ------------ @FastNative ---------------- - {"nSetBitmap", "(JLandroid/graphics/Bitmap;)V", (void*) CanvasJNI::setBitmap}, + {"nInitRaster", "(J)J", (void*) CanvasJNI::initRaster}, + {"nSetBitmap", "(JJ)V", (void*) CanvasJNI::setBitmap}, {"nGetClipBounds","(JLandroid/graphics/Rect;)Z", (void*) CanvasJNI::getClipBounds}, // ------------ @CriticalNative ---------------- @@ -706,10 +706,10 @@ static const JNINativeMethod gDrawMethods[] = { {"nDrawPath","(JJJ)V", (void*) CanvasJNI::drawPath}, {"nDrawVertices", "(JII[FI[FI[II[SIIJ)V", (void*)CanvasJNI::drawVertices}, {"nDrawNinePatch", "(JJJFFFFJII)V", (void*)CanvasJNI::drawNinePatch}, - {"nDrawBitmapMatrix", "(JLandroid/graphics/Bitmap;JJ)V", (void*)CanvasJNI::drawBitmapMatrix}, - {"nDrawBitmapMesh", "(JLandroid/graphics/Bitmap;II[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh}, - {"nDrawBitmap","(JLandroid/graphics/Bitmap;FFJIII)V", (void*) CanvasJNI::drawBitmap}, - {"nDrawBitmap","(JLandroid/graphics/Bitmap;FFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect}, + {"nDrawBitmapMatrix", "(JJJJ)V", (void*)CanvasJNI::drawBitmapMatrix}, + {"nDrawBitmapMesh", "(JJII[FI[IIJ)V", (void*)CanvasJNI::drawBitmapMesh}, + {"nDrawBitmap","(JJFFJIII)V", (void*) CanvasJNI::drawBitmap}, + {"nDrawBitmap","(JJFFFFFFFFJII)V", (void*) CanvasJNI::drawBitmapRect}, {"nDrawBitmap", "(J[IIIFFIIZJ)V", (void*)CanvasJNI::drawBitmapArray}, {"nDrawText","(J[CIIFFIJ)V", (void*) CanvasJNI::drawTextChars}, {"nDrawText","(JLjava/lang/String;IIFFIJ)V", (void*) CanvasJNI::drawTextString}, diff --git a/core/jni/android_view_ThreadedRenderer.cpp b/core/jni/android_view_ThreadedRenderer.cpp index ecc2dd0d3598..e7cbf938b128 100644 --- a/core/jni/android_view_ThreadedRenderer.cpp +++ b/core/jni/android_view_ThreadedRenderer.cpp @@ -736,11 +736,11 @@ static void android_view_ThreadedRenderer_buildLayer(JNIEnv* env, jobject clazz, } static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz, - jlong proxyPtr, jlong layerPtr, jobject jbitmap) { + jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) { RenderProxy* proxy = reinterpret_cast(proxyPtr); DeferredLayerUpdater* layer = reinterpret_cast(layerPtr); SkBitmap bitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); return proxy->copyLayerInto(layer, bitmap); } @@ -911,9 +911,9 @@ static void android_view_ThreadedRenderer_setFrameCompleteCallback(JNIEnv* env, static jint android_view_ThreadedRenderer_copySurfaceInto(JNIEnv* env, jobject clazz, jobject jsurface, jint left, jint top, - jint right, jint bottom, jobject jbitmap) { + jint right, jint bottom, jlong bitmapPtr) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); sp surface = android_view_Surface_getSurface(env, jsurface); return RenderProxy::copySurfaceInto(surface, left, top, right, bottom, &bitmap); } @@ -1106,7 +1106,7 @@ static const JNINativeMethod gMethods[] = { { "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor }, { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer }, { "nBuildLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_buildLayer }, - { "nCopyLayerInto", "(JJLandroid/graphics/Bitmap;)Z", (void*) android_view_ThreadedRenderer_copyLayerInto }, + { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto }, { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate }, { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate }, { "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture }, @@ -1135,7 +1135,7 @@ static const JNINativeMethod gMethods[] = { { "nRemoveFrameMetricsObserver", "(JJ)V", (void*)android_view_ThreadedRenderer_removeFrameMetricsObserver }, - { "nCopySurfaceInto", "(Landroid/view/Surface;IIIILandroid/graphics/Bitmap;)I", + { "nCopySurfaceInto", "(Landroid/view/Surface;IIIIJ)I", (void*)android_view_ThreadedRenderer_copySurfaceInto }, { "nCreateHardwareBitmap", "(JII)Landroid/graphics/Bitmap;", (void*)android_view_ThreadedRenderer_createHardwareBitmapFromRenderNode }, diff --git a/graphics/java/android/graphics/BaseCanvas.java b/graphics/java/android/graphics/BaseCanvas.java index fd3773588299..8ce649782924 100644 --- a/graphics/java/android/graphics/BaseCanvas.java +++ b/graphics/java/android/graphics/BaseCanvas.java @@ -112,14 +112,14 @@ public abstract class BaseCanvas { public void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) { throwIfCannotDraw(bitmap); throwIfHasHwBitmapInSwMode(paint); - nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, + nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, paint != null ? paint.getNativeInstance() : 0, mDensity, mScreenDensity, bitmap.mDensity); } public void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix, @Nullable Paint paint) { throwIfHasHwBitmapInSwMode(paint); - nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap, matrix.ni(), + nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap.getNativeInstance(), matrix.ni(), paint != null ? paint.getNativeInstance() : 0); } @@ -144,7 +144,7 @@ public abstract class BaseCanvas { bottom = src.bottom; } - nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom, + nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom, dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity, bitmap.mDensity); } @@ -170,7 +170,7 @@ public abstract class BaseCanvas { bottom = src.bottom; } - nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom, + nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom, dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity, bitmap.mDensity); } @@ -229,7 +229,7 @@ public abstract class BaseCanvas { // no mul by 2, since we need only 1 color per vertex checkRange(colors.length, colorOffset, count); } - nDrawBitmapMesh(mNativeCanvasWrapper, bitmap, meshWidth, meshHeight, + nDrawBitmapMesh(mNativeCanvasWrapper, bitmap.getNativeInstance(), meshWidth, meshHeight, verts, vertOffset, colors, colorOffset, paint != null ? paint.getNativeInstance() : 0); } @@ -664,10 +664,11 @@ public abstract class BaseCanvas { } } - private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, float left, float top, - long nativePaintOrZero, int canvasDensity, int screenDensity, int bitmapDensity); + private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float left, + float top, long nativePaintOrZero, int canvasDensity, int screenDensity, + int bitmapDensity); - private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, float srcLeft, + private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float srcLeft, float srcTop, float srcRight, float srcBottom, float dstLeft, float dstTop, float dstRight, float dstBottom, long nativePaintOrZero, int screenDensity, int bitmapDensity); @@ -726,10 +727,10 @@ public abstract class BaseCanvas { float dstLeft, float dstTop, float dstRight, float dstBottom, long nativePaintOrZero, int screenDensity, int bitmapDensity); - private static native void nDrawBitmapMatrix(long nativeCanvas, Bitmap bitmap, + private static native void nDrawBitmapMatrix(long nativeCanvas, long bitmapHandle, long nativeMatrix, long nativePaint); - private static native void nDrawBitmapMesh(long nativeCanvas, Bitmap bitmap, int meshWidth, + private static native void nDrawBitmapMesh(long nativeCanvas, long bitmapHandle, int meshWidth, int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset, long nativePaint); diff --git a/graphics/java/android/graphics/BaseRecordingCanvas.java b/graphics/java/android/graphics/BaseRecordingCanvas.java index 3e117411db01..1da10fb5b680 100644 --- a/graphics/java/android/graphics/BaseRecordingCanvas.java +++ b/graphics/java/android/graphics/BaseRecordingCanvas.java @@ -67,7 +67,7 @@ public class BaseRecordingCanvas extends Canvas { public final void drawBitmap(@NonNull Bitmap bitmap, float left, float top, @Nullable Paint paint) { throwIfCannotDraw(bitmap); - nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, + nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, paint != null ? paint.getNativeInstance() : 0, mDensity, mScreenDensity, bitmap.mDensity); } @@ -75,7 +75,7 @@ public class BaseRecordingCanvas extends Canvas { @Override public final void drawBitmap(@NonNull Bitmap bitmap, @NonNull Matrix matrix, @Nullable Paint paint) { - nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap, matrix.ni(), + nDrawBitmapMatrix(mNativeCanvasWrapper, bitmap.getNativeInstance(), matrix.ni(), paint != null ? paint.getNativeInstance() : 0); } @@ -100,7 +100,7 @@ public class BaseRecordingCanvas extends Canvas { bottom = src.bottom; } - nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom, + nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom, dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity, bitmap.mDensity); } @@ -126,7 +126,7 @@ public class BaseRecordingCanvas extends Canvas { bottom = src.bottom; } - nDrawBitmap(mNativeCanvasWrapper, bitmap, left, top, right, bottom, + nDrawBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance(), left, top, right, bottom, dst.left, dst.top, dst.right, dst.bottom, nativePaint, mScreenDensity, bitmap.mDensity); } @@ -188,7 +188,7 @@ public class BaseRecordingCanvas extends Canvas { // no mul by 2, since we need only 1 color per vertex checkRange(colors.length, colorOffset, count); } - nDrawBitmapMesh(mNativeCanvasWrapper, bitmap, meshWidth, meshHeight, + nDrawBitmapMesh(mNativeCanvasWrapper, bitmap.getNativeInstance(), meshWidth, meshHeight, verts, vertOffset, colors, colorOffset, paint != null ? paint.getNativeInstance() : 0); } @@ -581,11 +581,12 @@ public class BaseRecordingCanvas extends Canvas { } @FastNative - private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, float left, float top, - long nativePaintOrZero, int canvasDensity, int screenDensity, int bitmapDensity); + private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float left, + float top, long nativePaintOrZero, int canvasDensity, int screenDensity, + int bitmapDensity); @FastNative - private static native void nDrawBitmap(long nativeCanvas, Bitmap bitmap, + private static native void nDrawBitmap(long nativeCanvas, long bitmapHandle, float srcLeft, float srcTop, float srcRight, float srcBottom, float dstLeft, float dstTop, float dstRight, float dstBottom, long nativePaintOrZero, int screenDensity, int bitmapDensity); @@ -663,11 +664,11 @@ public class BaseRecordingCanvas extends Canvas { int screenDensity, int bitmapDensity); @FastNative - private static native void nDrawBitmapMatrix(long nativeCanvas, Bitmap bitmap, + private static native void nDrawBitmapMatrix(long nativeCanvas, long bitmapHandle, long nativeMatrix, long nativePaint); @FastNative - private static native void nDrawBitmapMesh(long nativeCanvas, Bitmap bitmap, int meshWidth, + private static native void nDrawBitmapMesh(long nativeCanvas, long bitmapHandle, int meshWidth, int meshHeight, float[] verts, int vertOffset, int[] colors, int colorOffset, long nativePaint); diff --git a/graphics/java/android/graphics/BitmapFactory.java b/graphics/java/android/graphics/BitmapFactory.java index d8a864015202..5623a8a49b35 100644 --- a/graphics/java/android/graphics/BitmapFactory.java +++ b/graphics/java/android/graphics/BitmapFactory.java @@ -464,6 +464,17 @@ public class BitmapFactory { } } + /** + * Helper for passing inBitmap's native pointer to native. + */ + static long nativeInBitmap(Options opts) { + if (opts == null || opts.inBitmap == null) { + return 0; + } + + return opts.inBitmap.getNativeInstance(); + } + /** * Helper for passing SkColorSpace pointer to native. * @@ -652,6 +663,7 @@ public class BitmapFactory { Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "decodeBitmap"); try { bm = nativeDecodeByteArray(data, offset, length, opts, + Options.nativeInBitmap(opts), Options.nativeColorSpace(opts)); if (bm == null && opts != null && opts.inBitmap != null) { @@ -747,7 +759,8 @@ public class BitmapFactory { try { if (is instanceof AssetManager.AssetInputStream) { final long asset = ((AssetManager.AssetInputStream) is).getNativeAsset(); - bm = nativeDecodeAsset(asset, outPadding, opts, Options.nativeColorSpace(opts)); + bm = nativeDecodeAsset(asset, outPadding, opts, Options.nativeInBitmap(opts), + Options.nativeColorSpace(opts)); } else { bm = decodeStreamInternal(is, outPadding, opts); } @@ -775,6 +788,7 @@ public class BitmapFactory { if (opts != null) tempStorage = opts.inTempStorage; if (tempStorage == null) tempStorage = new byte[DECODE_BUFFER_SIZE]; return nativeDecodeStream(is, tempStorage, outPadding, opts, + Options.nativeInBitmap(opts), Options.nativeColorSpace(opts)); } @@ -819,6 +833,7 @@ public class BitmapFactory { try { if (nativeIsSeekable(fd)) { bm = nativeDecodeFileDescriptor(fd, outPadding, opts, + Options.nativeInBitmap(opts), Options.nativeColorSpace(opts)); } else { FileInputStream fis = new FileInputStream(fd); @@ -856,15 +871,15 @@ public class BitmapFactory { @UnsupportedAppUsage private static native Bitmap nativeDecodeStream(InputStream is, byte[] storage, - Rect padding, Options opts, long colorSpaceHandle); + Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle); @UnsupportedAppUsage private static native Bitmap nativeDecodeFileDescriptor(FileDescriptor fd, - Rect padding, Options opts, long colorSpaceHandle); + Rect padding, Options opts, long inBitmapHandle, long colorSpaceHandle); @UnsupportedAppUsage private static native Bitmap nativeDecodeAsset(long nativeAsset, Rect padding, Options opts, - long colorSpaceHandle); + long inBitmapHandle, long colorSpaceHandle); @UnsupportedAppUsage private static native Bitmap nativeDecodeByteArray(byte[] data, int offset, - int length, Options opts, long colorSpaceHandle); + int length, Options opts, long inBitmapHandle, long colorSpaceHandle); private static native boolean nativeIsSeekable(FileDescriptor fd); } diff --git a/graphics/java/android/graphics/BitmapRegionDecoder.java b/graphics/java/android/graphics/BitmapRegionDecoder.java index 1410423eafac..629d8c131b68 100644 --- a/graphics/java/android/graphics/BitmapRegionDecoder.java +++ b/graphics/java/android/graphics/BitmapRegionDecoder.java @@ -196,6 +196,7 @@ public final class BitmapRegionDecoder { throw new IllegalArgumentException("rectangle is outside the image"); return nativeDecodeRegion(mNativeBitmapRegionDecoder, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, options, + BitmapFactory.Options.nativeInBitmap(options), BitmapFactory.Options.nativeColorSpace(options)); } } @@ -266,7 +267,8 @@ public final class BitmapRegionDecoder { private static native Bitmap nativeDecodeRegion(long lbm, int start_x, int start_y, int width, int height, - BitmapFactory.Options options, long colorSpaceHandle); + BitmapFactory.Options options, long inBitmapHandle, + long colorSpaceHandle); private static native int nativeGetWidth(long lbm); private static native int nativeGetHeight(long lbm); private static native void nativeClean(long lbm); diff --git a/graphics/java/android/graphics/BitmapShader.java b/graphics/java/android/graphics/BitmapShader.java index eb0f2e1e18f2..198d1e7bc956 100644 --- a/graphics/java/android/graphics/BitmapShader.java +++ b/graphics/java/android/graphics/BitmapShader.java @@ -62,9 +62,9 @@ public class BitmapShader extends Shader { @Override long createNativeInstance(long nativeMatrix) { - return nativeCreate(nativeMatrix, mBitmap, mTileX, mTileY); + return nativeCreate(nativeMatrix, mBitmap.getNativeInstance(), mTileX, mTileY); } - private static native long nativeCreate(long nativeMatrix, Bitmap bitmap, + private static native long nativeCreate(long nativeMatrix, long bitmapHandle, int shaderTileModeX, int shaderTileModeY); } diff --git a/graphics/java/android/graphics/Canvas.java b/graphics/java/android/graphics/Canvas.java index 7b3f3da111d5..5b00d11b36f3 100644 --- a/graphics/java/android/graphics/Canvas.java +++ b/graphics/java/android/graphics/Canvas.java @@ -95,7 +95,7 @@ public class Canvas extends BaseCanvas { public Canvas() { if (!isHardwareAccelerated()) { // 0 means no native bitmap - mNativeCanvasWrapper = nInitRaster(null); + mNativeCanvasWrapper = nInitRaster(0); mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation( this, mNativeCanvasWrapper); } else { @@ -117,7 +117,7 @@ public class Canvas extends BaseCanvas { throw new IllegalStateException("Immutable bitmap passed to Canvas constructor"); } throwIfCannotDraw(bitmap); - mNativeCanvasWrapper = nInitRaster(bitmap); + mNativeCanvasWrapper = nInitRaster(bitmap.getNativeInstance()); mFinalizer = NoImagePreloadHolder.sRegistry.registerNativeAllocation( this, mNativeCanvasWrapper); mBitmap = bitmap; @@ -185,7 +185,7 @@ public class Canvas extends BaseCanvas { } if (bitmap == null) { - nSetBitmap(mNativeCanvasWrapper, null); + nSetBitmap(mNativeCanvasWrapper, 0); mDensity = Bitmap.DENSITY_NONE; } else { if (!bitmap.isMutable()) { @@ -193,7 +193,7 @@ public class Canvas extends BaseCanvas { } throwIfCannotDraw(bitmap); - nSetBitmap(mNativeCanvasWrapper, bitmap); + nSetBitmap(mNativeCanvasWrapper, bitmap.getNativeInstance()); mDensity = bitmap.mDensity; } @@ -1364,14 +1364,16 @@ public class Canvas extends BaseCanvas { private static native void nFreeCaches(); private static native void nFreeTextLayoutCaches(); - private static native long nInitRaster(Bitmap bitmap); private static native long nGetNativeFinalizer(); private static native void nSetCompatibilityVersion(int apiLevel); // ---------------- @FastNative ------------------- @FastNative - private static native void nSetBitmap(long canvasHandle, Bitmap bitmap); + private static native long nInitRaster(long bitmapHandle); + + @FastNative + private static native void nSetBitmap(long canvasHandle, long bitmapHandle); @FastNative private static native boolean nGetClipBounds(long nativeCanvas, Rect bounds); diff --git a/graphics/java/android/graphics/HardwareRenderer.java b/graphics/java/android/graphics/HardwareRenderer.java index bc744cc7af3d..b6b2d4e1c46a 100644 --- a/graphics/java/android/graphics/HardwareRenderer.java +++ b/graphics/java/android/graphics/HardwareRenderer.java @@ -682,8 +682,8 @@ public class HardwareRenderer { /** @hide */ public boolean copyLayerInto(final TextureLayer layer, final Bitmap bitmap) { - return nCopyLayerInto(mNativeProxy, - layer.getDeferredLayerUpdater(), bitmap); + return nCopyLayerInto(mNativeProxy, layer.getDeferredLayerUpdater(), + bitmap.getNativeInstance()); } /** @@ -910,10 +910,10 @@ public class HardwareRenderer { public static int copySurfaceInto(Surface surface, Rect srcRect, Bitmap bitmap) { if (srcRect == null) { // Empty rect means entire surface - return nCopySurfaceInto(surface, 0, 0, 0, 0, bitmap); + return nCopySurfaceInto(surface, 0, 0, 0, 0, bitmap.getNativeInstance()); } else { return nCopySurfaceInto(surface, srcRect.left, srcRect.top, - srcRect.right, srcRect.bottom, bitmap); + srcRect.right, srcRect.bottom, bitmap.getNativeInstance()); } } @@ -1115,7 +1115,7 @@ public class HardwareRenderer { private static native void nBuildLayer(long nativeProxy, long node); - private static native boolean nCopyLayerInto(long nativeProxy, long layer, Bitmap bitmap); + private static native boolean nCopyLayerInto(long nativeProxy, long layer, long bitmapHandle); private static native void nPushLayerUpdate(long nativeProxy, long layer); @@ -1162,7 +1162,7 @@ public class HardwareRenderer { private static native void nRemoveFrameMetricsObserver(long nativeProxy, long nativeObserver); private static native int nCopySurfaceInto(Surface surface, - int srcLeft, int srcTop, int srcRight, int srcBottom, Bitmap bitmap); + int srcLeft, int srcTop, int srcRight, int srcBottom, long bitmapHandle); private static native Bitmap nCreateHardwareBitmap(long renderNode, int width, int height); diff --git a/graphics/java/android/graphics/NinePatch.java b/graphics/java/android/graphics/NinePatch.java index 800247af4927..c4c1eaceb4fc 100644 --- a/graphics/java/android/graphics/NinePatch.java +++ b/graphics/java/android/graphics/NinePatch.java @@ -261,7 +261,8 @@ public class NinePatch { * that are transparent. */ public final Region getTransparentRegion(Rect bounds) { - long r = nativeGetTransparentRegion(mBitmap, mNativeChunk, bounds); + long r = nativeGetTransparentRegion(mBitmap.getNativeInstance(), + mNativeChunk, bounds); return r != 0 ? new Region(r) : null; } @@ -282,5 +283,6 @@ public class NinePatch { */ private static native long validateNinePatchChunk(byte[] chunk); private static native void nativeFinalize(long chunk); - private static native long nativeGetTransparentRegion(Bitmap bitmap, long chunk, Rect location); + private static native long nativeGetTransparentRegion(long bitmapHandle, long chunk, + Rect location); } diff --git a/graphics/java/android/graphics/pdf/PdfRenderer.java b/graphics/java/android/graphics/pdf/PdfRenderer.java index 1836f009f86b..bd1a49205fd5 100644 --- a/graphics/java/android/graphics/pdf/PdfRenderer.java +++ b/graphics/java/android/graphics/pdf/PdfRenderer.java @@ -435,8 +435,9 @@ public final class PdfRenderer implements AutoCloseable { final long transformPtr = transform.native_instance; synchronized (sPdfiumLock) { - nativeRenderPage(mNativeDocument, mNativePage, destination, contentLeft, - contentTop, contentRight, contentBottom, transformPtr, renderMode); + nativeRenderPage(mNativeDocument, mNativePage, destination.getNativeInstance(), + contentLeft, contentTop, contentRight, contentBottom, transformPtr, + renderMode); } } @@ -487,7 +488,7 @@ public final class PdfRenderer implements AutoCloseable { private static native void nativeClose(long documentPtr); private static native int nativeGetPageCount(long documentPtr); private static native boolean nativeScaleForPrinting(long documentPtr); - private static native void nativeRenderPage(long documentPtr, long pagePtr, Bitmap dest, + private static native void nativeRenderPage(long documentPtr, long pagePtr, long bitmapHandle, int clipLeft, int clipTop, int clipRight, int clipBottom, long transformPtr, int renderMode); private static native long nativeOpenPageAndGetSize(long documentPtr, int pageIndex, diff --git a/opengl/java/android/opengl/GLUtils.java b/opengl/java/android/opengl/GLUtils.java index d0973359058a..ca8d5ac52021 100644 --- a/opengl/java/android/opengl/GLUtils.java +++ b/opengl/java/android/opengl/GLUtils.java @@ -44,7 +44,7 @@ public final class GLUtils { if (bitmap.isRecycled()) { throw new IllegalArgumentException("bitmap is recycled"); } - int result = native_getInternalFormat(bitmap); + int result = native_getInternalFormat(bitmap.getNativeInstance()); if (result < 0) { throw new IllegalArgumentException("Unknown internalformat"); } @@ -66,7 +66,7 @@ public final class GLUtils { if (bitmap.isRecycled()) { throw new IllegalArgumentException("bitmap is recycled"); } - int result = native_getType(bitmap); + int result = native_getType(bitmap.getNativeInstance()); if (result < 0) { throw new IllegalArgumentException("Unknown type"); } @@ -103,7 +103,8 @@ public final class GLUtils { if (bitmap.isRecycled()) { throw new IllegalArgumentException("bitmap is recycled"); } - if (native_texImage2D(target, level, internalformat, bitmap, -1, border)!=0) { + if (native_texImage2D(target, level, internalformat, bitmap.getNativeInstance(), -1, + border) != 0) { throw new IllegalArgumentException("invalid Bitmap format"); } } @@ -129,7 +130,8 @@ public final class GLUtils { if (bitmap.isRecycled()) { throw new IllegalArgumentException("bitmap is recycled"); } - if (native_texImage2D(target, level, internalformat, bitmap, type, border)!=0) { + if (native_texImage2D(target, level, internalformat, bitmap.getNativeInstance(), type, + border) != 0) { throw new IllegalArgumentException("invalid Bitmap format"); } } @@ -151,7 +153,7 @@ public final class GLUtils { if (bitmap.isRecycled()) { throw new IllegalArgumentException("bitmap is recycled"); } - if (native_texImage2D(target, level, -1, bitmap, -1, border)!=0) { + if (native_texImage2D(target, level, -1, bitmap.getNativeInstance(), -1, border) != 0) { throw new IllegalArgumentException("invalid Bitmap format"); } } @@ -187,7 +189,8 @@ public final class GLUtils { throw new IllegalArgumentException("bitmap is recycled"); } int type = getType(bitmap); - if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap, -1, type)!=0) { + if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap.getNativeInstance(), -1, + type) != 0) { throw new IllegalArgumentException("invalid Bitmap format"); } } @@ -211,7 +214,8 @@ public final class GLUtils { if (bitmap.isRecycled()) { throw new IllegalArgumentException("bitmap is recycled"); } - if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap, format, type)!=0) { + if (native_texSubImage2D(target, level, xoffset, yoffset, bitmap.getNativeInstance(), + format, type) != 0) { throw new IllegalArgumentException("invalid Bitmap format"); } } @@ -261,10 +265,10 @@ public final class GLUtils { } } - native private static int native_getInternalFormat(Bitmap bitmap); - native private static int native_getType(Bitmap bitmap); + native private static int native_getInternalFormat(long bitmapHandle); + native private static int native_getType(long bitmapHandle); native private static int native_texImage2D(int target, int level, int internalformat, - Bitmap bitmap, int type, int border); + long bitmapHandle, int type, int border); native private static int native_texSubImage2D(int target, int level, int xoffset, int yoffset, - Bitmap bitmap, int format, int type); + long bitmapHandle, int format, int type); } diff --git a/rs/java/android/renderscript/RenderScript.java b/rs/java/android/renderscript/RenderScript.java index 85c82bc009a0..f4c27771c846 100644 --- a/rs/java/android/renderscript/RenderScript.java +++ b/rs/java/android/renderscript/RenderScript.java @@ -447,27 +447,33 @@ public class RenderScript { validate(); return rsnAllocationCreateTyped(mContext, type, mip, usage, pointer); } - native long rsnAllocationCreateFromBitmap(long con, long type, int mip, Bitmap bmp, int usage); + native long rsnAllocationCreateFromBitmap(long con, long type, int mip, long bitmapHandle, + int usage); synchronized long nAllocationCreateFromBitmap(long type, int mip, Bitmap bmp, int usage) { validate(); - return rsnAllocationCreateFromBitmap(mContext, type, mip, bmp, usage); + return rsnAllocationCreateFromBitmap(mContext, type, mip, bmp.getNativeInstance(), usage); } - native long rsnAllocationCreateBitmapBackedAllocation(long con, long type, int mip, Bitmap bmp, int usage); - synchronized long nAllocationCreateBitmapBackedAllocation(long type, int mip, Bitmap bmp, int usage) { + native long rsnAllocationCreateBitmapBackedAllocation(long con, long type, int mip, long bitmapHandle, + int usage); + synchronized long nAllocationCreateBitmapBackedAllocation(long type, int mip, Bitmap bmp, + int usage) { validate(); - return rsnAllocationCreateBitmapBackedAllocation(mContext, type, mip, bmp, usage); + return rsnAllocationCreateBitmapBackedAllocation(mContext, type, mip, bmp.getNativeInstance(), + usage); } - native long rsnAllocationCubeCreateFromBitmap(long con, long type, int mip, Bitmap bmp, int usage); + native long rsnAllocationCubeCreateFromBitmap(long con, long type, int mip, long bitmapHandle, + int usage); synchronized long nAllocationCubeCreateFromBitmap(long type, int mip, Bitmap bmp, int usage) { validate(); - return rsnAllocationCubeCreateFromBitmap(mContext, type, mip, bmp, usage); + return rsnAllocationCubeCreateFromBitmap(mContext, type, mip, bmp.getNativeInstance(), + usage); } - native long rsnAllocationCreateBitmapRef(long con, long type, Bitmap bmp); + native long rsnAllocationCreateBitmapRef(long con, long type, long bitmapHandle); synchronized long nAllocationCreateBitmapRef(long type, Bitmap bmp) { validate(); - return rsnAllocationCreateBitmapRef(mContext, type, bmp); + return rsnAllocationCreateBitmapRef(mContext, type, bmp.getNativeInstance()); } native long rsnAllocationCreateFromAssetStream(long con, int mips, int assetStream, int usage); synchronized long nAllocationCreateFromAssetStream(int mips, int assetStream, int usage) { @@ -475,10 +481,10 @@ public class RenderScript { return rsnAllocationCreateFromAssetStream(mContext, mips, assetStream, usage); } - native void rsnAllocationCopyToBitmap(long con, long alloc, Bitmap bmp); + native void rsnAllocationCopyToBitmap(long con, long alloc, long bitmapHandle); synchronized void nAllocationCopyToBitmap(long alloc, Bitmap bmp) { validate(); - rsnAllocationCopyToBitmap(mContext, alloc, bmp); + rsnAllocationCopyToBitmap(mContext, alloc, bmp.getNativeInstance()); } native void rsnAllocationSyncAll(long con, long alloc, int src); @@ -487,8 +493,10 @@ public class RenderScript { rsnAllocationSyncAll(mContext, alloc, src); } - native ByteBuffer rsnAllocationGetByteBuffer(long con, long alloc, long[] stride, int xBytesSize, int dimY, int dimZ); - synchronized ByteBuffer nAllocationGetByteBuffer(long alloc, long[] stride, int xBytesSize, int dimY, int dimZ) { + native ByteBuffer rsnAllocationGetByteBuffer(long con, long alloc, long[] stride, + int xBytesSize, int dimY, int dimZ); + synchronized ByteBuffer nAllocationGetByteBuffer(long alloc, long[] stride, int xBytesSize, + int dimY, int dimZ) { validate(); return rsnAllocationGetByteBuffer(mContext, alloc, stride, xBytesSize, dimY, dimZ); } @@ -529,10 +537,10 @@ public class RenderScript { validate(); rsnAllocationGenerateMipmaps(mContext, alloc); } - native void rsnAllocationCopyFromBitmap(long con, long alloc, Bitmap bmp); + native void rsnAllocationCopyFromBitmap(long con, long alloc, long bitmapHandle); synchronized void nAllocationCopyFromBitmap(long alloc, Bitmap bmp) { validate(); - rsnAllocationCopyFromBitmap(mContext, alloc, bmp); + rsnAllocationCopyFromBitmap(mContext, alloc, bmp.getNativeInstance()); } diff --git a/rs/jni/android_renderscript_RenderScript.cpp b/rs/jni/android_renderscript_RenderScript.cpp index 52d0e08e4e7f..dfee96182a48 100644 --- a/rs/jni/android_renderscript_RenderScript.cpp +++ b/rs/jni/android_renderscript_RenderScript.cpp @@ -1321,10 +1321,10 @@ nAllocationGenerateMipmaps(JNIEnv *_env, jobject _this, jlong con, jlong alloc) static jlong nAllocationCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip, - jobject jbitmap, jint usage) + jlong bitmapPtr, jint usage) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); const void* ptr = bitmap.getPixels(); jlong id = (jlong)(uintptr_t)rsAllocationCreateFromBitmap((RsContext)con, @@ -1335,10 +1335,10 @@ nAllocationCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, static jlong nAllocationCreateBitmapBackedAllocation(JNIEnv *_env, jobject _this, jlong con, jlong type, - jint mip, jobject jbitmap, jint usage) + jint mip, jlong bitmapPtr, jint usage) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); const void* ptr = bitmap.getPixels(); jlong id = (jlong)(uintptr_t)rsAllocationCreateTyped((RsContext)con, @@ -1349,10 +1349,10 @@ nAllocationCreateBitmapBackedAllocation(JNIEnv *_env, jobject _this, jlong con, static jlong nAllocationCubeCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong type, jint mip, - jobject jbitmap, jint usage) + jlong bitmapPtr, jint usage) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); const void* ptr = bitmap.getPixels(); jlong id = (jlong)(uintptr_t)rsAllocationCubeCreateFromBitmap((RsContext)con, @@ -1362,10 +1362,10 @@ nAllocationCubeCreateFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong ty } static void -nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap) +nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jlong bitmapPtr) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); int w = bitmap.width(); int h = bitmap.height(); @@ -1376,10 +1376,10 @@ nAllocationCopyFromBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, j } static void -nAllocationCopyToBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jobject jbitmap) +nAllocationCopyToBitmap(JNIEnv *_env, jobject _this, jlong con, jlong alloc, jlong bitmapPtr) { SkBitmap bitmap; - GraphicsJNI::getSkBitmap(_env, jbitmap, &bitmap); + bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap); void* ptr = bitmap.getPixels(); rsAllocationCopyToBitmap((RsContext)con, (RsAllocation)alloc, ptr, bitmap.computeByteSize()); @@ -2866,13 +2866,13 @@ static const JNINativeMethod methods[] = { {"rsnTypeCreate", "(JJIIIZZI)J", (void*)nTypeCreate }, {"rsnTypeGetNativeData", "(JJ[J)V", (void*)nTypeGetNativeData }, -{"rsnAllocationCreateTyped", "(JJIIJ)J", (void*)nAllocationCreateTyped }, -{"rsnAllocationCreateFromBitmap", "(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCreateFromBitmap }, -{"rsnAllocationCreateBitmapBackedAllocation", "(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCreateBitmapBackedAllocation }, -{"rsnAllocationCubeCreateFromBitmap","(JJILandroid/graphics/Bitmap;I)J", (void*)nAllocationCubeCreateFromBitmap }, +{"rsnAllocationCreateTyped", "(JJIIJ)J", (void*)nAllocationCreateTyped }, +{"rsnAllocationCreateFromBitmap", "(JJIJI)J", (void*)nAllocationCreateFromBitmap }, +{"rsnAllocationCreateBitmapBackedAllocation", "(JJIJI)J", (void*)nAllocationCreateBitmapBackedAllocation }, +{"rsnAllocationCubeCreateFromBitmap","(JJIJI)J", (void*)nAllocationCubeCreateFromBitmap }, -{"rsnAllocationCopyFromBitmap", "(JJLandroid/graphics/Bitmap;)V", (void*)nAllocationCopyFromBitmap }, -{"rsnAllocationCopyToBitmap", "(JJLandroid/graphics/Bitmap;)V", (void*)nAllocationCopyToBitmap }, +{"rsnAllocationCopyFromBitmap", "(JJJ)V", (void*)nAllocationCopyFromBitmap }, +{"rsnAllocationCopyToBitmap", "(JJJ)V", (void*)nAllocationCopyToBitmap }, {"rsnAllocationSyncAll", "(JJI)V", (void*)nAllocationSyncAll }, {"rsnAllocationSetupBufferQueue", "(JJI)V", (void*)nAllocationSetupBufferQueue }, -- cgit v1.2.3-59-g8ed1b From 43ef0c3d9b8fc909d45479fa92f2f91240309a81 Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Wed, 3 Apr 2019 17:30:40 -0600 Subject: EGLAttrib requires special handling in JNI EGLAttrib is defined for a C / C++ interface and is intended to be the size of a pointer. That can change depending on which abi the code is built for but Java doesn't have a way of dealing with such types. Java defines EGLAttrib as a jlong, so need to convert jlong to 32bit when running on a 32bit device. Bug: 124382141 Test: atest --all-abi CtsGraphicsTestCases:EGL15Test Change-Id: I966f6a3716b2710e17d10e0d0cb58314853675e0 --- core/jni/android_opengl_EGL15.cpp | 139 +++++++++++++++++++--------------- opengl/java/android/opengl/EGL15.java | 23 +++--- 2 files changed, 93 insertions(+), 69 deletions(-) (limited to 'opengl/java') diff --git a/core/jni/android_opengl_EGL15.cpp b/core/jni/android_opengl_EGL15.cpp index 99bdce274f3e..717b50579325 100644 --- a/core/jni/android_opengl_EGL15.cpp +++ b/core/jni/android_opengl_EGL15.cpp @@ -25,6 +25,7 @@ #include #include +#include #include #include @@ -206,6 +207,24 @@ toEGLHandle(JNIEnv *_env, jclass cls, jmethodID con, void *handle) { return _env->NewObject(cls, con, reinterpret_cast(handle)); } +struct WrappedEGLAttribs { +private: + std::vector backing; // only for 32-bit +public: + EGLAttrib *attribs; + WrappedEGLAttribs(): attribs(nullptr) { }; + void init(jlong *array, jint size) { + if (sizeof(EGLAttrib) != sizeof(jlong)) { + for (jint i = 0; i < size; ++i) { + backing.push_back(array[i]); + } + attribs = backing.data(); + } else { + attribs = (EGLAttrib*)array; + } + } +}; + // -------------------------------------------------------------------------- /* EGLSync eglCreateSync ( EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list ) */ static jobject @@ -216,9 +235,9 @@ android_eglCreateSync const char * _exceptionMessage = NULL; EGLSync _returnValue = (EGLSync) 0; EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); - EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jlong *attrib_list_base = (jlong *) 0; jint _remaining; - EGLAttrib *attrib_list = (EGLAttrib *) 0; + WrappedEGLAttribs attrib_list; if (!attrib_list_ref) { _exception = 1; @@ -233,14 +252,14 @@ android_eglCreateSync goto exit; } _remaining = _env->GetArrayLength(attrib_list_ref) - offset; - attrib_list_base = (EGLAttrib *) + attrib_list_base = (jlong *) _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); - attrib_list = attrib_list_base + offset; + attrib_list.init(attrib_list_base + offset, _remaining); _returnValue = eglCreateSync( (EGLDisplay)dpy_native, (EGLenum)type, - (EGLAttrib *)attrib_list + attrib_list.attribs ); exit: @@ -255,38 +274,6 @@ exit: return toEGLHandle(_env, eglsyncClass, eglsyncConstructor, _returnValue); } -/* EGLBoolean eglDestroySync ( EGLDisplay dpy, EGLSync sync ) */ -static jboolean -android_eglDestroySync - (JNIEnv *_env, jobject _this, jobject dpy, jobject sync) { - EGLBoolean _returnValue = (EGLBoolean) 0; - EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); - EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); - - _returnValue = eglDestroySync( - (EGLDisplay)dpy_native, - (EGLSync)sync_native - ); - return (jboolean)_returnValue; -} - -/* EGLint eglClientWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout ) */ -static jint -android_eglClientWaitSync - (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint flags, jlong timeout) { - EGLint _returnValue = (EGLint) 0; - EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); - EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); - - _returnValue = eglClientWaitSync( - (EGLDisplay)dpy_native, - (EGLSync)sync_native, - (EGLint)flags, - (EGLTime)timeout - ); - return (jint)_returnValue; -} - /* EGLBoolean eglGetSyncAttrib ( EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value ) */ static jboolean android_eglGetSyncAttrib @@ -297,9 +284,9 @@ android_eglGetSyncAttrib EGLBoolean _returnValue = (EGLBoolean) 0; EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); - EGLAttrib *value_base = (EGLAttrib *) 0; + jlong *value_base = (jlong *) 0; jint _remaining; - EGLAttrib *value = (EGLAttrib *) 0; + EGLAttrib value; if (!value_ref) { _exception = 1; @@ -314,17 +301,20 @@ android_eglGetSyncAttrib goto exit; } _remaining = _env->GetArrayLength(value_ref) - offset; - value_base = (EGLAttrib *) + value_base = (jlong *) _env->GetLongArrayElements(value_ref, (jboolean *)0); - value = value_base + offset; _returnValue = eglGetSyncAttrib( (EGLDisplay)dpy_native, (EGLSync)sync_native, (EGLint)attribute, - (EGLAttrib *)value + &value ); + if (value_base && _returnValue == EGL_TRUE) { + *(value_base + offset) = (jlong) value; + } + exit: if (value_base) { _env->ReleaseLongArrayElements(value_ref, (jlong*)value_base, @@ -337,6 +327,38 @@ exit: return (jboolean)_returnValue; } +/* EGLBoolean eglDestroySync ( EGLDisplay dpy, EGLSync sync ) */ +static jboolean +android_eglDestroySync + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync) { + EGLBoolean _returnValue = (EGLBoolean) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + + _returnValue = eglDestroySync( + (EGLDisplay)dpy_native, + (EGLSync)sync_native + ); + return (jboolean)_returnValue; +} + +/* EGLint eglClientWaitSync ( EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout ) */ +static jint +android_eglClientWaitSync + (JNIEnv *_env, jobject _this, jobject dpy, jobject sync, jint flags, jlong timeout) { + EGLint _returnValue = (EGLint) 0; + EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); + EGLSync sync_native = (EGLSync) fromEGLHandle(_env, eglsyncGetHandleID, sync); + + _returnValue = eglClientWaitSync( + (EGLDisplay)dpy_native, + (EGLSync)sync_native, + (EGLint)flags, + (EGLTime)timeout + ); + return (jint)_returnValue; +} + /* EGLDisplay eglGetPlatformDisplay ( EGLenum platform, EGLAttrib native_display, const EGLAttrib *attrib_list ) */ static jobject android_eglGetPlatformDisplay @@ -345,9 +367,9 @@ android_eglGetPlatformDisplay const char * _exceptionType = NULL; const char * _exceptionMessage = NULL; EGLDisplay _returnValue = (EGLDisplay) 0; - EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jlong *attrib_list_base = (jlong *) 0; jint _remaining; - EGLAttrib *attrib_list = (EGLAttrib *) 0; + WrappedEGLAttribs attrib_list; if (!attrib_list_ref) { _exception = 1; @@ -362,14 +384,14 @@ android_eglGetPlatformDisplay goto exit; } _remaining = _env->GetArrayLength(attrib_list_ref) - offset; - attrib_list_base = (EGLAttrib *) + attrib_list_base = (jlong *) _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); - attrib_list = attrib_list_base + offset; + attrib_list.init(attrib_list_base + offset, _remaining); _returnValue = eglGetPlatformDisplay( (EGLenum)platform, (void *)native_display, - (EGLAttrib *)attrib_list + attrib_list.attribs ); exit: @@ -398,9 +420,9 @@ android_eglCreatePlatformWindowSurface EGLConfig config_native = (EGLConfig) fromEGLHandle(_env, eglconfigGetHandleID, config); jint _native_windowRemaining; void *native_window = (void *) 0; - EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jlong *attrib_list_base = (jlong *) 0; jint _attrib_listRemaining; - EGLAttrib *attrib_list = (EGLAttrib *) 0; + WrappedEGLAttribs attrib_list; if (!native_window_buf) { _exception = 1; @@ -422,9 +444,9 @@ android_eglCreatePlatformWindowSurface goto exit; } _attrib_listRemaining = _env->GetArrayLength(attrib_list_ref) - offset; - attrib_list_base = (EGLAttrib *) + attrib_list_base = (jlong *) _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); - attrib_list = attrib_list_base + offset; + attrib_list.init(attrib_list_base + offset, _attrib_listRemaining); if (native_window == NULL) { char * _native_windowBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0); @@ -434,7 +456,7 @@ android_eglCreatePlatformWindowSurface (EGLDisplay)dpy_native, (EGLConfig)config_native, (void *)native_window, - (EGLAttrib *)attrib_list + attrib_list.attribs ); exit: @@ -487,9 +509,9 @@ android_eglCreateImage EGLImage _returnValue = (EGLImage) 0; EGLDisplay dpy_native = (EGLDisplay) fromEGLHandle(_env, egldisplayGetHandleID, dpy); EGLContext context_native = (EGLContext) fromEGLHandle(_env, eglcontextGetHandleID, context); - EGLAttrib *attrib_list_base = (EGLAttrib *) 0; + jlong *attrib_list_base = (jlong *) 0; jint _remaining; - EGLAttrib *attrib_list = (EGLAttrib *) 0; + WrappedEGLAttribs attrib_list; if (!attrib_list_ref) { _exception = 1; @@ -504,16 +526,16 @@ android_eglCreateImage goto exit; } _remaining = _env->GetArrayLength(attrib_list_ref) - offset; - attrib_list_base = (EGLAttrib *) + attrib_list_base = (jlong *) _env->GetLongArrayElements(attrib_list_ref, (jboolean *)0); - attrib_list = attrib_list_base + offset; + attrib_list.init(attrib_list_base + offset, _remaining); _returnValue = eglCreateImage( (EGLDisplay)dpy_native, (EGLContext)context_native, (EGLenum)target, (EGLClientBuffer)buffer, - (EGLAttrib *)attrib_list + attrib_list.attribs ); exit: @@ -527,7 +549,6 @@ exit: } return toEGLHandle(_env, eglimageClass, eglimageConstructor, _returnValue); } - /* EGLBoolean eglDestroyImage ( EGLDisplay dpy, EGLImage image ) */ static jboolean android_eglDestroyImage @@ -548,9 +569,9 @@ static const char *classPathName = "android/opengl/EGL15"; static const JNINativeMethod methods[] = { {"_nativeClassInit", "()V", (void*)nativeClassInit }, {"eglCreateSync", "(Landroid/opengl/EGLDisplay;I[JI)Landroid/opengl/EGLSync;", (void *) android_eglCreateSync }, +{"eglGetSyncAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;I[JI)Z", (void *) android_eglGetSyncAttrib }, {"eglDestroySync", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;)Z", (void *) android_eglDestroySync }, {"eglClientWaitSync", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;IJ)I", (void *) android_eglClientWaitSync }, -{"eglGetSyncAttrib", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLSync;I[JI)Z", (void *) android_eglGetSyncAttrib }, {"eglGetPlatformDisplay", "(IJ[JI)Landroid/opengl/EGLDisplay;", (void *) android_eglGetPlatformDisplay }, {"eglCreatePlatformWindowSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/nio/Buffer;[JI)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePlatformWindowSurface }, {"eglCreatePlatformPixmapSurface", "(Landroid/opengl/EGLDisplay;Landroid/opengl/EGLConfig;Ljava/nio/Buffer;[JI)Landroid/opengl/EGLSurface;", (void *) android_eglCreatePlatformPixmapSurface }, diff --git a/opengl/java/android/opengl/EGL15.java b/opengl/java/android/opengl/EGL15.java index bd845e7ec1a0..93acc674a4b7 100644 --- a/opengl/java/android/opengl/EGL15.java +++ b/opengl/java/android/opengl/EGL15.java @@ -85,6 +85,19 @@ public final class EGL15 { int offset ); + /** + * C function EGLBoolean eglGetSyncAttrib ( EGLDisplay dpy, EGLSync sync, EGLint attribute, + * EGLAttrib *value ) + */ + + public static native boolean eglGetSyncAttrib( + EGLDisplay dpy, + EGLSync sync, + int attribute, + long[] value, + int offset + ); + // C function EGLBoolean eglDestroySync ( EGLDisplay dpy, EGLSync sync ) public static native boolean eglDestroySync( @@ -101,16 +114,6 @@ public final class EGL15 { long timeout ); - // C function EGLBoolean eglGetSyncAttrib ( EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value ) - - public static native boolean eglGetSyncAttrib( - EGLDisplay dpy, - EGLSync sync, - int attribute, - long[] value, - int offset - ); - // C function EGLDisplay eglGetPlatformDisplay ( EGLenum platform, EGLAttrib native_display, const EGLAttrib *attrib_list ) public static native EGLDisplay eglGetPlatformDisplay( -- cgit v1.2.3-59-g8ed1b