auto import from //depot/cupcake/@135843
diff --git a/core/jni/com_google_android_gles_jni_EGLImpl.cpp b/core/jni/com_google_android_gles_jni_EGLImpl.cpp
new file mode 100644
index 0000000..fbbd852
--- /dev/null
+++ b/core/jni/com_google_android_gles_jni_EGLImpl.cpp
@@ -0,0 +1,470 @@
+/*
+**
+** Copyright 2006, 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.
+*/
+
+#include <android_runtime/AndroidRuntime.h>
+#include <utils/misc.h>
+
+#include <EGL/egl.h>
+#include <GLES/gl.h>
+
+#include <ui/EGLNativeWindowSurface.h>
+#include <ui/Surface.h>
+#include <SkBitmap.h>
+#include <SkPixelRef.h>
+
+namespace android {
+
+static jclass gDisplay_class;
+static jclass gContext_class;
+static jclass gSurface_class;
+static jclass gConfig_class;
+
+static jmethodID gConfig_ctorID;
+
+static jfieldID gDisplay_EGLDisplayFieldID;
+static jfieldID gContext_EGLContextFieldID;
+static jfieldID gSurface_EGLSurfaceFieldID;
+static jfieldID gSurface_NativePixelRefFieldID;
+static jfieldID gConfig_EGLConfigFieldID;
+static jfieldID gSurface_SurfaceFieldID;
+static jfieldID gBitmap_NativeBitmapFieldID;
+
+static __attribute__((noinline))
+void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL)
+{
+ jclass npeClazz = env->FindClass(exc);
+ env->ThrowNew(npeClazz, msg);
+}
+
+static __attribute__((noinline))
+bool hasException(JNIEnv *env) {
+ if (env->ExceptionCheck() != 0) {
+ env->ExceptionDescribe();
+ return true;
+ }
+ return false;
+}
+
+static __attribute__((noinline))
+jclass make_globalref(JNIEnv* env, const char classname[]) {
+ jclass c = env->FindClass(classname);
+ return (jclass)env->NewGlobalRef(c);
+}
+
+static inline EGLDisplay getDisplay(JNIEnv* env, jobject o) {
+ if (!o) return EGL_NO_DISPLAY;
+ return (EGLDisplay)env->GetIntField(o, gDisplay_EGLDisplayFieldID);
+}
+static inline EGLSurface getSurface(JNIEnv* env, jobject o) {
+ if (!o) return EGL_NO_SURFACE;
+ return (EGLSurface)env->GetIntField(o, gSurface_EGLSurfaceFieldID);
+}
+static inline EGLContext getContext(JNIEnv* env, jobject o) {
+ if (!o) return EGL_NO_CONTEXT;
+ return (EGLContext)env->GetIntField(o, gContext_EGLContextFieldID);
+}
+static inline EGLConfig getConfig(JNIEnv* env, jobject o) {
+ if (!o) return 0;
+ return (EGLConfig)env->GetIntField(o, gConfig_EGLConfigFieldID);
+}
+static void nativeClassInit(JNIEnv *_env, jclass eglImplClass)
+{
+ gDisplay_class = make_globalref(_env, "com/google/android/gles_jni/EGLDisplayImpl");
+ gContext_class = make_globalref(_env, "com/google/android/gles_jni/EGLContextImpl");
+ gSurface_class = make_globalref(_env, "com/google/android/gles_jni/EGLSurfaceImpl");
+ gConfig_class = make_globalref(_env, "com/google/android/gles_jni/EGLConfigImpl");
+
+ gConfig_ctorID = _env->GetMethodID(gConfig_class, "<init>", "(I)V");
+
+ gDisplay_EGLDisplayFieldID = _env->GetFieldID(gDisplay_class, "mEGLDisplay", "I");
+ gContext_EGLContextFieldID = _env->GetFieldID(gContext_class, "mEGLContext", "I");
+ gSurface_EGLSurfaceFieldID = _env->GetFieldID(gSurface_class, "mEGLSurface", "I");
+ gSurface_NativePixelRefFieldID = _env->GetFieldID(gSurface_class, "mNativePixelRef", "I");
+ gConfig_EGLConfigFieldID = _env->GetFieldID(gConfig_class, "mEGLConfig", "I");
+
+ jclass surface_class = _env->FindClass("android/view/Surface");
+ gSurface_SurfaceFieldID = _env->GetFieldID(surface_class, "mSurface", "I");
+
+ jclass bitmap_class = _env->FindClass("android/graphics/Bitmap");
+ gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "I");
+}
+
+jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display,
+ jintArray major_minor) {
+
+ EGLDisplay dpy = getDisplay(_env, display);
+ jboolean success = eglInitialize(dpy, NULL, NULL);
+ if (success && major_minor) {
+ int len = _env->GetArrayLength(major_minor);
+ if (len) {
+ // we're exposing only EGL 1.0
+ jint* base = (jint *)_env->GetPrimitiveArrayCritical(major_minor, (jboolean *)0);
+ if (len >= 1) base[0] = 1;
+ if (len >= 2) base[1] = 0;
+ _env->ReleasePrimitiveArrayCritical(major_minor, base, JNI_ABORT);
+ }
+ }
+ return success;
+}
+
+jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display,
+ jobject context, jint attribute, jintArray value) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLContext ctx = getContext(_env, context);
+ if (value == NULL) {
+ doThrow(_env, "java/lang/NullPointerException");
+ return JNI_FALSE;
+ }
+ jboolean success = JNI_FALSE;
+ int len = _env->GetArrayLength(value);
+ if (len) {
+ jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0);
+ success = eglQueryContext(dpy, ctx, attribute, base);
+ _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT);
+ }
+ return success;
+}
+
+jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display,
+ jobject surface, jint attribute, jintArray value) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLContext sur = getSurface(_env, surface);
+ if (value == NULL) {
+ doThrow(_env, "java/lang/NullPointerException");
+ return JNI_FALSE;
+ }
+ jboolean success = JNI_FALSE;
+ int len = _env->GetArrayLength(value);
+ if (len) {
+ jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0);
+ success = eglQuerySurface(dpy, sur, attribute, base);
+ _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT);
+ }
+ return success;
+}
+
+jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display,
+ jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ if (attrib_list==NULL || configs==NULL || num_config==NULL) {
+ doThrow(_env, "java/lang/NullPointerException");
+ return JNI_FALSE;
+ }
+ jboolean success = JNI_FALSE;
+ jint* attrib_base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);
+ jint* num_base = (jint *)_env->GetPrimitiveArrayCritical(num_config, (jboolean *)0);
+ EGLConfig nativeConfigs[config_size];
+ success = eglChooseConfig(dpy, attrib_base, nativeConfigs, config_size, num_base);
+ int num = num_base[0];
+ _env->ReleasePrimitiveArrayCritical(num_config, num_base, JNI_ABORT);
+ _env->ReleasePrimitiveArrayCritical(attrib_list, attrib_base, JNI_ABORT);
+ if (success) {
+ for (int i=0 ; i<num ; i++) {
+ jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]);
+ _env->SetObjectArrayElement(configs, i, obj);
+ }
+ }
+ return success;
+}
+
+jint jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display,
+ jobject config, jobject share_context, jintArray attrib_list) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLConfig cnf = getConfig(_env, config);
+ EGLContext shr = getContext(_env, share_context);
+ jint* base = 0;
+ if (attrib_list) {
+ // XXX: if array is malformed, we should return an NPE instead of segfault
+ base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);
+ }
+ EGLContext ctx = eglCreateContext(dpy, cnf, shr, base);
+ if (attrib_list) {
+ _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);
+ }
+ return (jint)ctx;
+}
+
+jint jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display,
+ jobject config, jintArray attrib_list) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLConfig cnf = getConfig(_env, config);
+ jint* base = 0;
+ if (attrib_list) {
+ // XXX: if array is malformed, we should return an NPE instead of segfault
+ base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);
+ }
+ EGLSurface sur = eglCreatePbufferSurface(dpy, cnf, base);
+ if (attrib_list) {
+ _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);
+ }
+ return (jint)sur;
+}
+
+static PixelFormat convertPixelFormat(SkBitmap::Config format)
+{
+ switch (format) {
+ case SkBitmap::kARGB_8888_Config: return PIXEL_FORMAT_RGBA_8888;
+ case SkBitmap::kARGB_4444_Config: return PIXEL_FORMAT_RGBA_4444;
+ case SkBitmap::kRGB_565_Config: return PIXEL_FORMAT_RGB_565;
+ case SkBitmap::kA8_Config: return PIXEL_FORMAT_A_8;
+ default: return PIXEL_FORMAT_NONE;
+ }
+}
+
+void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur,
+ jobject display, jobject config, jobject native_pixmap,
+ jintArray attrib_list)
+{
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLConfig cnf = getConfig(_env, config);
+ jint* base = 0;
+
+ SkBitmap const * nativeBitmap =
+ (SkBitmap const *)_env->GetIntField(native_pixmap,
+ gBitmap_NativeBitmapFieldID);
+ SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0;
+ if (ref == NULL) {
+ doThrow(_env, "java/lang/NullPointerException", "Bitmap has no PixelRef");
+ return;
+ }
+
+ ref->safeRef();
+ ref->lockPixels();
+
+ egl_native_pixmap_t pixmap;
+ pixmap.version = sizeof(pixmap);
+ pixmap.width = nativeBitmap->width();
+ pixmap.height = nativeBitmap->height();
+ pixmap.stride = nativeBitmap->rowBytes() / nativeBitmap->bytesPerPixel();
+ pixmap.format = convertPixelFormat(nativeBitmap->config());
+ pixmap.data = (uint8_t*)ref->pixels();
+
+ if (attrib_list) {
+ // XXX: if array is malformed, we should return an NPE instead of segfault
+ base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);
+ }
+ EGLSurface sur = eglCreatePixmapSurface(dpy, cnf, &pixmap, base);
+ if (attrib_list) {
+ _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);
+ }
+
+ if (sur != EGL_NO_SURFACE) {
+ _env->SetIntField(out_sur, gSurface_EGLSurfaceFieldID, (int)sur);
+ _env->SetIntField(out_sur, gSurface_NativePixelRefFieldID, (int)ref);
+ } else {
+ ref->unlockPixels();
+ ref->safeUnref();
+ }
+}
+
+jint jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display,
+ jobject config, jobject native_window, jintArray attrib_list) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLContext cnf = getConfig(_env, config);
+ Surface* window = 0;
+ if (native_window == NULL) {
+not_valid_surface:
+ doThrow(_env, "java/lang/NullPointerException",
+ "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface");
+ return 0;
+ }
+ window = (Surface*)_env->GetIntField(native_window, gSurface_SurfaceFieldID);
+ if (window == NULL)
+ goto not_valid_surface;
+
+ jint* base = 0;
+ if (attrib_list) {
+ // XXX: if array is malformed, we should return an NPE instead of segfault
+ base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0);
+ }
+ EGLSurface sur = eglCreateWindowSurface(dpy, cnf, new EGLNativeWindowSurface(window), base);
+ if (attrib_list) {
+ _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT);
+ }
+ return (jint)sur;
+}
+
+jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display,
+ jobject config, jint attribute, jintArray value) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLContext cnf = getConfig(_env, config);
+ if (value == NULL) {
+ doThrow(_env, "java/lang/NullPointerException");
+ return JNI_FALSE;
+ }
+ jboolean success = JNI_FALSE;
+ int len = _env->GetArrayLength(value);
+ if (len) {
+ jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0);
+ success = eglGetConfigAttrib(dpy, cnf, attribute, base);
+ _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT);
+ }
+ return success;
+}
+
+jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display,
+ jobjectArray configs, jint config_size, jintArray num_config) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ jboolean success = JNI_FALSE;
+ if (num_config == NULL) {
+ doThrow(_env, "java/lang/NullPointerException");
+ return JNI_FALSE;
+ }
+ jint* num_base = (jint *)_env->GetPrimitiveArrayCritical(num_config, (jboolean *)0);
+ EGLConfig nativeConfigs[config_size];
+ success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, num_base);
+ int num = num_base[0];
+ _env->ReleasePrimitiveArrayCritical(num_config, num_base, JNI_ABORT);
+
+ if (success && configs) {
+ for (int i=0 ; i<num ; i++) {
+ jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]);
+ _env->SetObjectArrayElement(configs, i, obj);
+ }
+ }
+ return success;
+}
+
+jint jni_eglGetError(JNIEnv *_env, jobject _this) {
+ EGLint error = eglGetError();
+ return error;
+}
+
+jint jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) {
+ return (jint)eglGetCurrentContext();
+}
+
+jint jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) {
+ return (jint)eglGetCurrentDisplay();
+}
+
+jint jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) {
+ return (jint)eglGetCurrentSurface(readdraw);
+}
+
+jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLContext ctx = getContext(_env, context);
+ return eglDestroyContext(dpy, ctx);
+}
+
+jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLSurface sur = getSurface(_env, surface);
+
+ if (sur) {
+ SkPixelRef* ref = (SkPixelRef*)(_env->GetIntField(surface,
+ gSurface_NativePixelRefFieldID));
+ if (ref) {
+ ref->unlockPixels();
+ ref->safeUnref();
+ }
+ }
+ return eglDestroySurface(dpy, sur);
+}
+
+jint jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {
+ return (jint)eglGetDisplay(EGL_DEFAULT_DISPLAY);
+}
+
+jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLSurface sdr = getSurface(_env, draw);
+ EGLSurface srd = getSurface(_env, read);
+ EGLContext ctx = getContext(_env, context);
+ return eglMakeCurrent(dpy, sdr, srd, ctx);
+}
+
+jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ const char* chars = eglQueryString(dpy, name);
+ return _env->NewStringUTF(chars);
+}
+
+jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ EGLSurface sur = getSurface(_env, surface);
+ return eglSwapBuffers(dpy, sur);
+}
+
+jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) {
+ EGLDisplay dpy = getDisplay(_env, display);
+ return eglTerminate(dpy);
+}
+
+jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display,
+ jobject surface, jobject native_pixmap) {
+ // TODO: implement me
+ return JNI_FALSE;
+}
+
+jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) {
+ return eglWaitGL();
+}
+
+jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) {
+ return eglWaitNative(engine);
+}
+
+
+static const char *classPathName = "com/google/android/gles_jni/EGLImpl";
+
+#define DISPLAY "Ljavax/microedition/khronos/egl/EGLDisplay;"
+#define CONTEXT "Ljavax/microedition/khronos/egl/EGLContext;"
+#define CONFIG "Ljavax/microedition/khronos/egl/EGLConfig;"
+#define SURFACE "Ljavax/microedition/khronos/egl/EGLSurface;"
+#define OBJECT "Ljava/lang/Object;"
+#define STRING "Ljava/lang/String;"
+
+static JNINativeMethod methods[] = {
+{"_nativeClassInit","()V", (void*)nativeClassInit },
+{"eglWaitGL", "()Z", (void*)jni_eglWaitGL },
+{"eglInitialize", "(" DISPLAY "[I)Z", (void*)jni_eglInitialize },
+{"eglQueryContext", "(" DISPLAY CONTEXT "I[I)Z", (void*)jni_eglQueryContext },
+{"eglQuerySurface", "(" DISPLAY SURFACE "I[I)Z", (void*)jni_eglQuerySurface },
+{"eglChooseConfig", "(" DISPLAY "[I[" CONFIG "I[I)Z", (void*)jni_eglChooseConfig },
+{"_eglCreateContext","(" DISPLAY CONFIG CONTEXT "[I)I", (void*)jni_eglCreateContext },
+{"eglGetConfigs", "(" DISPLAY "[" CONFIG "I[I)Z", (void*)jni_eglGetConfigs },
+{"eglTerminate", "(" DISPLAY ")Z", (void*)jni_eglTerminate },
+{"eglCopyBuffers", "(" DISPLAY SURFACE OBJECT ")Z", (void*)jni_eglCopyBuffers },
+{"eglWaitNative", "(I" OBJECT ")Z", (void*)jni_eglWaitNative },
+{"eglGetError", "()I", (void*)jni_eglGetError },
+{"eglGetConfigAttrib", "(" DISPLAY CONFIG "I[I)Z", (void*)jni_eglGetConfigAttrib },
+{"_eglGetDisplay", "(" OBJECT ")I", (void*)jni_eglGetDisplay },
+{"_eglGetCurrentContext", "()I", (void*)jni_eglGetCurrentContext },
+{"_eglGetCurrentDisplay", "()I", (void*)jni_eglGetCurrentDisplay },
+{"_eglGetCurrentSurface", "(I)I", (void*)jni_eglGetCurrentSurface },
+{"_eglCreatePbufferSurface","(" DISPLAY CONFIG "[I)I", (void*)jni_eglCreatePbufferSurface },
+{"_eglCreatePixmapSurface", "(" SURFACE DISPLAY CONFIG OBJECT "[I)V", (void*)jni_eglCreatePixmapSurface },
+{"_eglCreateWindowSurface", "(" DISPLAY CONFIG OBJECT "[I)I", (void*)jni_eglCreateWindowSurface },
+{"eglDestroyContext", "(" DISPLAY CONTEXT ")Z", (void*)jni_eglDestroyContext },
+{"eglDestroySurface", "(" DISPLAY SURFACE ")Z", (void*)jni_eglDestroySurface },
+{"eglMakeCurrent", "(" DISPLAY SURFACE SURFACE CONTEXT")Z", (void*)jni_eglMakeCurrent },
+{"eglQueryString", "(" DISPLAY "I)" STRING, (void*)jni_eglQueryString },
+{"eglSwapBuffers", "(" DISPLAY SURFACE ")Z", (void*)jni_eglSwapBuffers },
+};
+
+} // namespace android
+
+int register_com_google_android_gles_jni_EGLImpl(JNIEnv *_env)
+{
+ int err;
+ err = android::AndroidRuntime::registerNativeMethods(_env,
+ android::classPathName, android::methods, NELEM(android::methods));
+ return err;
+}
+