Android端在native层初始化OpenGL ES环境流程

素颜马尾好姑娘i 2022-05-24 02:04 718阅读 0赞

之前学习OpenGL的时候，基本上都是使用GLSurfaceView来初始化，然后调用OpenGL的API来进行绘制。然而找OpenGL的教程时，发现基本上的教程都是C，这就很尴尬了呀，Android平台虽然也封装了名字类似的Java 的API，但是总感觉怪怪的。大概看了一下GLSurfaceView的源码，其实就是继承SurfaceView，然后开启一个线程来初始化EGL环境，接着也是使用OpenGL的API来绘制。那么EGL是什么呢？

> EGL™在Khronos 的图形渲染API比如 OpenGL ES or Open VG与本地系统底层窗口之间的接口。它处理图形上下文管理，表面/缓冲区绑定和渲染同步，并使用其他Khronos API实现高性能，加速，混合模式2D和3D渲染。

下面我们通过分析EglHelper来查看native代码的初始化流程。  
EglHelper类中，初始化主要调用了两个方法。

/**
             * Initialize EGL for a given configuration spec.
             * @param configSpec
             */
            public void start() {
                if (LOG_EGL) {
                    Log.w("EglHelper", "start() tid=" + Thread.currentThread().getId());
                }
                /*
                 * Get an EGL instance
                 */
                mEgl = (EGL10) EGLContext.getEGL();
    
                /*
                 * Get to the default display.
                 */
                mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
    
                if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
                    throw new RuntimeException("eglGetDisplay failed");
                }
    
                /*
                 * We can now initialize EGL for that display
                 */
                int[] version = new int[2];
                if(!mEgl.eglInitialize(mEglDisplay, version)) {
                    throw new RuntimeException("eglInitialize failed");
                }
                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                if (view == null) {
                    mEglConfig = null;
                    mEglContext = null;
                } else {
                    mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
    
                    /*
                    * Create an EGL context. We want to do this as rarely as we can, because an
                    * EGL context is a somewhat heavy object.
                    */
                    mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
                }
                if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
                    mEglContext = null;
                    throwEglException("createContext");
                }
                if (LOG_EGL) {
                    Log.w("EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId());
                }
    
                mEglSurface = null;
            }

/**
             * Create an egl surface for the current SurfaceHolder surface. If a surface
             * already exists, destroy it before creating the new surface.
             *
             * @return true if the surface was created successfully.
             */
            public boolean createSurface() {
                if (LOG_EGL) {
                    Log.w("EglHelper", "createSurface()  tid=" + Thread.currentThread().getId());
                }
                /*
                 * Check preconditions.
                 */
                if (mEgl == null) {
                    throw new RuntimeException("egl not initialized");
                }
                if (mEglDisplay == null) {
                    throw new RuntimeException("eglDisplay not initialized");
                }
                if (mEglConfig == null) {
                    throw new RuntimeException("mEglConfig not initialized");
                }
    
                /*
                 *  The window size has changed, so we need to create a new
                 *  surface.
                 */
                destroySurfaceImp();
    
                /*
                 * Create an EGL surface we can render into.
                 */
                GLSurfaceView view = mGLSurfaceViewWeakRef.get();
                if (view != null) {
                    mEglSurface = view.mEGLWindowSurfaceFactory.createWindowSurface(mEgl,
                            mEglDisplay, mEglConfig, view.getHolder());
                } else {
                    mEglSurface = null;
                }
    
                if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
                    int error = mEgl.eglGetError();
                    if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
                        Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
                    }
                    return false;
                }
    
                /*
                 * Before we can issue GL commands, we need to make sure
                 * the context is current and bound to a surface.
                 */
                if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
                    /*
                     * Could not make the context current, probably because the underlying
                     * SurfaceView surface has been destroyed.
                     */
                    logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
                    return false;
                }
    
                return true;
            }

大部分的实现在EGLImpl类中，大概看一下初始化环境的流程。

##### 1、eglGetDisplay #####

这里首先调用了native方法，然后封装了一个EGLDisplayImpl返回。先看native方法。

public synchronized EGLDisplay eglGetDisplay(Object native_display) {
            long value = _eglGetDisplay(native_display);
            if (value == 0) {
               return EGL10.EGL_NO_DISPLAY;
           }
            if (mDisplay.mEGLDisplay != value)
               mDisplay = new EGLDisplayImpl(value);
           return mDisplay;
        }

这个cpp文件是com\_google\_android\_gles\_jni\_EGLImpl.cpp,调用了eglGetDisplay方法返回一个jlong。

static jlong jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) {
        return reinterpret_cast<jlong>(eglGetDisplay(EGL_DEFAULT_DISPLAY));
    }

##### 2、eglInitialize #####

这个直接是一个native方法，通过解封装拿到上一步初始化的EGLDisplayImpl里的mEGLDisplay（所以封装一层的目的是什么）。然后调用eglInitialize()进行初始化。

static jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display,
           jintArray major_minor) {
        if (display == NULL || (major_minor != NULL &&
                _env->GetArrayLength(major_minor) < 2)) {
            jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
            return JNI_FALSE;
        }
        EGLDisplay dpy = getDisplay(_env, display);
        EGLBoolean success = eglInitialize(dpy, NULL, NULL);
        if (success && major_minor) {
            int len = _env->GetArrayLength(major_minor);
            if (len) {
                // we're exposing only EGL 1.0
                //我们在将java类型转到native时，可能会使用的是拷贝数据或者jvm堆中的原始数据
                //该方法严格请求原始数据的指针，然而jvm同样可能会创建新的副本
                //而且使用的时候会有诸多限制
                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, 0);
            }
        }
        return EglBoolToJBool(success);
    }

##### 3、chooseConfig #####

接下来是chooseConfig，先看GLSurfaceView中的实现，大概就是先获取config的数量，然后再获取实际的config,并进行筛选。

public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {
                int[] num_config = new int[1];
                if (!egl.eglChooseConfig(display, mConfigSpec, null, 0,
                        num_config)) {
                    throw new IllegalArgumentException("eglChooseConfig failed");
                }
    
                int numConfigs = num_config[0];
    
                if (numConfigs <= 0) {
                    throw new IllegalArgumentException(
                            "No configs match configSpec");
                }
    
                EGLConfig[] configs = new EGLConfig[numConfigs];
                if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
                        num_config)) {
                    throw new IllegalArgumentException("eglChooseConfig#2 failed");
                }
                EGLConfig config = chooseConfig(egl, display, configs);
                if (config == null) {
                    throw new IllegalArgumentException("No config chosen");
                }
                return config;
            }

egl.eglChooseConfig同样是一个native方法，从实现我们可以看到,如果第configs参数为NULL将只返回config的数量，如果不为NULL将会生成新的java对象，填充回该对象的class为com/google/android/gles\_jni/EGLConfigImpl。最终获取的在configs数组中。

static jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display,
            jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) {
        if (display == NULL
            || !validAttribList(_env, attrib_list)
            || (configs != NULL && _env->GetArrayLength(configs) < config_size)
            || (num_config != NULL && _env->GetArrayLength(num_config) < 1)) {
            jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
            return JNI_FALSE;
        }
        EGLDisplay dpy = getDisplay(_env, display);
        EGLBoolean success = EGL_FALSE;
    
        if (configs == NULL) {
            config_size = 0;
        }
        EGLConfig nativeConfigs[config_size];
    
        int num = 0;
        jint* attrib_base = beginNativeAttribList(_env, attrib_list);
        success = eglChooseConfig(dpy, attrib_base, configs ? nativeConfigs : 0, config_size, &num);
        endNativeAttributeList(_env, attrib_list, attrib_base);
    
        if (num_config != NULL) {
            _env->SetIntArrayRegion(num_config, 0, 1, (jint*) &num);
        }
    
        if (success && configs!=NULL) {
            for (int i=0 ; i<num ; i++) {
                jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, reinterpret_cast<jlong>(nativeConfigs[i]));
                _env->SetObjectArrayElement(configs, i, obj);
            }
        }
        return EglBoolToJBool(success);
    }

##### 4、createContext #####

拿到config后我们就可以创建上下文了。这里在java层也是调用jni方法，然后简单封装返回。

public EGLContext eglCreateContext(EGLDisplay display, EGLConfig config, EGLContext share_context, int[] attrib_list) {
            long eglContextId = _eglCreateContext(display, config, share_context, attrib_list);
            if (eglContextId == 0) {
                return EGL10.EGL_NO_CONTEXT;
            }
            return new EGLContextImpl( eglContextId );
       }

native方法，通过反射拿到对应的值，java包装类中的属性，然后创建eglCreateContext

static jlong jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display,
            jobject config, jobject share_context, jintArray attrib_list) {
        if (display == NULL || config == NULL || share_context == NULL
            || !validAttribList(_env, attrib_list)) {
            jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
            return JNI_FALSE;
        }
        EGLDisplay dpy = getDisplay(_env, display);
        EGLConfig  cnf = getConfig(_env, config);
        EGLContext shr = getContext(_env, share_context);
        jint* base = beginNativeAttribList(_env, attrib_list);
        EGLContext ctx = eglCreateContext(dpy, cnf, shr, base);
        endNativeAttributeList(_env, attrib_list, base);
        return reinterpret_cast<jlong>(ctx);
    }

##### 5、eglCreateWindowSurface #####

接下来是eglCreateWindowSurface，我们先拿到surface,然后调用native方法创建WindoSurface。

public EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list) {
          Surface sur = null;
          if (native_window instanceof SurfaceView) {
              SurfaceView surfaceView = (SurfaceView)native_window;
              sur = surfaceView.getHolder().getSurface();
          } else if (native_window instanceof SurfaceHolder) {
              SurfaceHolder holder = (SurfaceHolder)native_window;
              sur = holder.getSurface();
          } else if (native_window instanceof Surface) {
              sur = (Surface) native_window;
          }
    
          long eglSurfaceId;
          if (sur != null) {
              eglSurfaceId = _eglCreateWindowSurface(display, config, sur, attrib_list);
          } else if (native_window instanceof SurfaceTexture) {
              eglSurfaceId = _eglCreateWindowSurfaceTexture(display, config,
                      native_window, attrib_list);
          } else {
              throw new java.lang.UnsupportedOperationException(
                  "eglCreateWindowSurface() can only be called with an instance of " +
                  "Surface, SurfaceView, SurfaceHolder or SurfaceTexture at the moment.");
           }
    
           if (eglSurfaceId == 0) {
               return EGL10.EGL_NO_SURFACE;
           }
           return new EGLSurfaceImpl( eglSurfaceId );
       }

这个方法也比较简单，一开是又是去拿包装类的属性，然后\_eglCreateWindowSurface

static jlong jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display,
            jobject config, jobject native_window, jintArray attrib_list) {
        if (display == NULL || config == NULL
            || !validAttribList(_env, attrib_list)) {
            jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
            return JNI_FALSE;
        }
        EGLDisplay dpy = getDisplay(_env, display);
        EGLContext cnf = getConfig(_env, config);
        sp<ANativeWindow> window;
        if (native_window == NULL) {
    not_valid_surface:
            jniThrowException(_env, "java/lang/IllegalArgumentException",
                    "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface");
            return 0;
        }
    
        window = android_view_Surface_getNativeWindow(_env, native_window);
        if (window == NULL)
            goto not_valid_surface;
    
        jint* base = beginNativeAttribList(_env, attrib_list);
        EGLSurface sur = eglCreateWindowSurface(dpy, cnf, window.get(), base);
        endNativeAttributeList(_env, attrib_list, base);
        return reinterpret_cast<jlong>(sur);
    }

##### 6、eglMakeCurrent #####

最后一步也是直接调用eglMakeCurrent，这里中间又通过反射去拿属性，所以封装过去封装过来，头疼。。

static jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) {
        if (display == NULL || draw == NULL || read == NULL || context == NULL) {
            jniThrowException(_env, "java/lang/IllegalArgumentException", NULL);
            return JNI_FALSE;
        }
        EGLDisplay dpy = getDisplay(_env, display);
        EGLSurface sdr = getSurface(_env, draw);
        EGLSurface srd = getSurface(_env, read);
        EGLContext ctx = getContext(_env, context);
        return EglBoolToJBool(eglMakeCurrent(dpy, sdr, srd, ctx));
    }

总之，这几步完成之后，我们终于可以通过OpenGL的API来绘制东西了。在java层我们只需要额外传一个surface就可以了，其他的都可以在native层操作了，绘制完成之后要记得调用eglSwapBuffers来将数据显示在屏幕上。下一篇文章照例分析书上的OpenGL的demo。最后附上一些参考资料。

*  [EGL文档][EGL]
 *  [OpenGL ES 2.0参考文档][OpenGL ES 2.0]
 *  [EGL规范pdf][EGL_pdf]
 *  [EGL版本概览][EGL 1]

[EGL]: https://www.khronos.org/registry/EGL/sdk/docs/man/
[OpenGL ES 2.0]: https://www.khronos.org/registry/OpenGL-Refpages/es2.0/
[EGL_pdf]: https://www.khronos.org/registry/EGL/specs/eglspec.1.5.pdf
[EGL 1]: https://www.khronos.org/registry/EGL/