Android OpenGL ES

http://blog.csdn.net/hgl868/article/details/6971624

1.    OpenGL ES 简介

Android 3D引擎采用的是OpenGL ES。OpenGL ES是一套为手持和嵌入式系统设计的3D引擎API，由Khronos公司维护。在PC领域，一直有两种标准的3D API进行竞争，OpenGL 和 DirectX。一般主流的游戏和显卡都支持这两种渲染方式，DirectX在Windows平台上有很大的优势，但是OpenGL具有更好的跨平台性。

由于嵌入式系统和PC相比，一般说来，CPU、内存等都比PC差很多，而且对能耗有着特殊的要求，许多嵌入式设备并没有浮点运算协处理器，针对嵌入式系统的以上特点，Khronos对标准的OpenGL系统进行了维护和改动，以期望满足嵌入式设备对3D绘图的要求。

2.    Android OpenGL ES简介

Android系统使用OpenGL的标准接口来支持3D图形功能，android 3D图形系统也分为java框架和本地代码两部分。本地代码主要实现的OpenGL接口的库，在Java框架层，javax.microedition.khronos.opengles是java标准的OpenGL包，android.opengl包提供了OpenGL系统和Android GUI系统之间的联系。

Android的本地代码位于frameworks/base/opengl下,JNI代码位于frameworks/base/core/com_google_android_gles_jni_GLImpl.cpp和frameworks/base/core/com_google_android_gles_jni_EGLImpl.cpp，java类位于opengl/java/javax/microedition/khronos下

3.    OpenGL的本地代码分析

3.1 OpenGL ES测试代码

frameworks/base/opengl/tests下有OpenGL的本地测试代码。包括angeles、fillrate等14个测试代码，这些代码都可以通过终端进行本地调用测试（模拟器中使用adb shell）。在本文中，主要使用了tritex这个测试用例。

在tests文件夹中执行mm，打印出以下信息

Install: out/target/product/generic/system/bin/angeles

…

Install: out/target/product/generic/system/bin/test-opengl-tritex

         由以上信息可知，测试用例被安装在了out/target/product/generic/system/bin/目录下，将之拷贝到nfs文件系统中，以便测试。我把这些测试用例都单独放在android的根文件系统的gltest文件夹中了。

 

3.2  OpenGL ES的编译

编译libagl下的源码生成Install: out/target/product/generic/system/lib/egl/libGLES_android.so

编译libs下的生成了

Install: out/target/product/generic/system/lib/libGLESv2.so

Install: out/target/product/generic/system/lib/libGLESv1_CM.so

Install: out/target/product/generic/system/lib/libEGL.so

3.3 使用OpenGL ES画图必经的步骤  

1、获取Display，Display代表显示器。

    函数原型：

    EGLDisplay eglGetDisplay(NativeDisplayType display);

    display参数是native系统的窗口显示ID值，一般为 EGL_DEFAULT_DISPLAY 。该参数实际的意义是平台实现相关的，在X-Window下是XDisplay ID，在MS Windows下是Window DC。

2、初始化egl库。

    函数原型：

    EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);

    其中dpy应该是一个有效的 EGLDisplay 。函数返回时，major和minor将被赋予当前EGL版本号。

3、选择一个合适的EGL Configuration FrameBuffer，实际指的是FrameBuffer的参数

    函数原型：

       EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list,EGLConfig *configs, EGLint config_size,

                           EGLint *num_config);

    参数attrib_list：指定了选择配置时需要参照的属性。

    参数configs：    将返回一个按照attrib_list排序的平台有效的所有EGL framebuffer配置列表。

    参数config_size：指定了可以返回到configs的总配置个数。

    参数num_config： 返回了实际匹配的配置总数。

4、创建一个可实际显示的EGLSurface，实际上就是一个FrameBuffer

    函数原型：

    EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config,

                                  NativeWindowType win,

                                  const EGLint *attrib_list);

5、创建Context

    函数原型：

    EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config,

                            EGLContext share_context,

                            const EGLint *attrib_list);

6、绑定Display、Surface、Context

    函数原型：

    EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw,

                          EGLSurface read, EGLContext ctx);

3.4 OpenGL ES 执行过程

运行android操作系统之后，输入logcat命令，然后执行gltest中的test-opengl-tritex,屏幕上打印了以下信息

D/libEGL  ( 1962): egl.cfg not found, using default config

D/libEGL  ( 1962): loaded /system/lib/egl/libGLES_android.so

可以看出，在执行OpenGL调用的过程中，会自动加载libGLES_android.so动态链接库。后面将会通过分析和修改源码的方式，了解OpenGL ES系统的调用过程。

通过3.3中的说明，我们在tritex测试程序中插入一些调试信息，查看OpenGL ES的调用过程。

在调用eglGetDisplay之前会执行early_egl_init函数，这是一个静态的函数。

在eglGetDisplay中会去初始化驱动，最终调用到egl_init_drivers_locked函数中。这个函数的主要内容如下

EGLBoolean egl_init_drivers_locked()

{

    if (sEarlyInitState) {

        // initialized by static ctor. should be set here.

        return EGL_FALSE;

    }

    // get our driver loader

    Loader& loader(Loader::getInstance());

    // dynamically load all our EGL implementations for all displays

    // and retrieve the corresponding EGLDisplay

    // if that fails, don't use this driver.

    // TODO: currently we only deal with EGL_DEFAULT_DISPLAY

    egl_connection_t* cnx;

    egl_display_t* d = &gDisplay[0];

 

    cnx = &gEGLImpl[IMPL_SOFTWARE];

    if (cnx->dso == 0) {

        cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_SOFTWARE];

        cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_SOFTWARE];

        cnx->dso = loader.open(EGL_DEFAULT_DISPLAY, 0, cnx);

        if (cnx->dso) {

            EGLDisplay dpy = cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);

            LOGE_IF(dpy==EGL_NO_DISPLAY, "No EGLDisplay for software EGL!");

            d->disp[IMPL_SOFTWARE].dpy = dpy;

            if (dpy == EGL_NO_DISPLAY) {

                loader.close(cnx->dso);

                cnx->dso = NULL;

            }

        }

    }

 

    cnx = &gEGLImpl[IMPL_HARDWARE];

    if (cnx->dso == 0) {

        char value[PROPERTY_VALUE_MAX];

        property_get("debug.egl.hw", value, "1");

        if (atoi(value) != 0) {

            cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_HARDWARE];

            cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_HARDWARE];

            cnx->dso = loader.open(EGL_DEFAULT_DISPLAY, 1, cnx);

            if (cnx->dso) {

                EGLDisplay dpy = cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);

                LOGE_IF(dpy==EGL_NO_DISPLAY, "No EGLDisplay for hardware EGL!");

                d->disp[IMPL_HARDWARE].dpy = dpy;

                if (dpy == EGL_NO_DISPLAY) {

                    loader.close(cnx->dso);

                    cnx->dso = NULL;

                }

            }

        } else {

            LOGD("3D hardware acceleration is disabled");

        }

    }

 

    if (!gEGLImpl[IMPL_SOFTWARE].dso && !gEGLImpl[IMPL_HARDWARE].dso) {

        return EGL_FALSE;

    }

 

    return EGL_TRUE;

}

由此代码可以看出，egl_init_drivers_locked函数主要的工作就是填充gEGLImp数组变量，这个变量是egl_connection_t类型。还有一个工作就是填充gDisplay数组（只有一个元素）的disp[IMPL_HARDWARE].dpy以及disp[IMPLSOFTWAREWARE].dpy，填充的来源来自gEGLImpl【soft or hard】.egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);

在Loader.cpp中的Loader::open中会加载对应的硬件和软件加速的驱动（动态链接库）。软件的对应的是/system/lib/egl/libEGL_android.so，没有默认的硬件so，因此在硬件加速时，返回值hnd会指向NULL，在需要硬件加速时这个动态链接库需要进行实现。

LoadDriver函数会根据其第三个参数，决定加载egl/gles,glesv1_cm,glesv2驱动。。。

加载几个动态链接库的过程如下图

由我以上图表可以看出，加载驱动的时候，会尝试先从libGLES_android.so中加载EGL、GLESV1_CM、GLESV2三个部分的函数，如

果加载失败，则会尝试从libEGL_android.so，libGLESV1_cm.so，libGLESV2.so三个动态库中对应的函数。在这部分代码中，我们可以看到一个非常重要的结构体，egl_connection_t，

struct egl_connection_t

{

    void *              dso;

    gl_hooks_t *        hooks[2];

    EGLint              major;

    EGLint              minor;

    egl_t               egl;

};到处都有他的身影，对这几个变量进行一下解释。

struct soinfo

{

    const char name[SOINFO_NAME_LEN];

    Elf32_Phdr *phdr;

    int phnum;

    unsigned entry;

    unsigned base;

    unsigned size;

    // buddy-allocator index, negative for prelinked libraries

    int ba_index;

    unsigned *dynamic;

    unsigned wrprotect_start;

    unsigned wrprotect_end;

    soinfo *next;

    unsigned flags;

    const char *strtab;

    Elf32_Sym *symtab;

 

    unsigned nbucket;

    unsigned nchain;

    unsigned *bucket;

    unsigned *chain;

 

    unsigned *plt_got;

 

    Elf32_Rel *plt_rel;

    unsigned plt_rel_count;

 

    Elf32_Rel *rel;

    unsigned rel_count;

 

    unsigned *preinit_array;

    unsigned preinit_array_count;

 

    unsigned *init_array;

    unsigned init_array_count;

    unsigned *fini_array;

    unsigned fini_array_count;

 

    void (*init_func)(void);

    void (*fini_func)(void);

 

#ifdef ANDROID_ARM_LINKER

    /* ARM EABI section used for stack unwinding. */

    unsigned *ARM_exidx;

    unsigned ARM_exidx_count;

#endif

 

    unsigned refcount;

    struct link_map linkmap;

};

看一下load_driver中到底做了什么手脚。

1.首先调用dlopen打开动态链接库，返回值是void*,这个void*指向的是什么内容呢？追踪到bionic/linker/Dlfcn.c中。其中调用了find_library函数，这个函数是一个奇怪的函数，因为它虽然叫做find_library，在其实现中，不但在系统的so链表中去查找指定的文件名的动态链接库信息，而且对其动态链接库进行加载并返回。至此我们明白了，这个void* 指向的是一个soinfo类型的结构体

这是man dlopen的说明。一个标准的linux函数。

The function dlopen() loads the dynamic library file named by the null-

       terminated  string  filename  and  returns  an  opaque "handle" for the

       dynamic library.  If filename is NULL, then the returned handle is  for

       the  main  program.   If  filename  contains  a slash ("/"), then it is

       interpreted as a  (relative  or  absolute)  pathname. 

 

2. 由上一步的分析，我们知道了egl_connection_t的第一个变量dso，是指向的一个soinfo结构体（discover/decompress shared

object的缩写？？？）

Printf("HAHA Let me print the so infomation\n");

    Printf("name=%s:phdr=%x:entry=%x:base=%x:size=%x\n",soi->name,soi->phdr,soi->entry,soi->base,soi->size);

这是上一条语句打印的一些信息。

name=libGLES_android.so:phdr=acc80034:entry=0:base=acc80000:size=1c000

 

3.dlsym可以根据dlopen的返回值，查找第二个参数指定的函数名的地址并返回

The  function dlsym() takes a "handle" of a dynamic library returned by

       dlopen() and the null-terminated symbol  name,  returning  the  address

       where  that  symbol is loaded into memory.  If the symbol is not found,

       in the specified library or any of the libraries  that  were  automati-

       cally  loaded by dlopen() when that library was loaded, dlsym() returns

       NULL.  (The search performed by dlsym() is breadth  first  through  the

       dependency  tree  of  these  libraries.)  Since the value of the symbol

       could actually be NULL (so that a NULL return  from  dlsym()  need  not

       indicate  an  error),  the  correct way to test for an error is to call

       dlerror() to clear any old error conditions,  then  call  dlsym(),  and

       then call dlerror() again, saving its return value into a variable, and

       check whether this saved value is not NULL.

 

getProcAddress = (getProcAddressType)dlsym(dso, "eglGetProcAddress");

        Printf("eglGetProcAddress's location is %x\n",getProcAddress);

打印信息如下，可以和刚才的打印信息比较一下。我们确实找到了一个函数。

eglGetProcAddress's location is acc930b1

 

Printf("curr=%x,it's address is %x\n",curr,f);

打印如下

eglGetProcAddress's location is acc930b1

*api=eglGetDisplay

curr=ac708a60,it's address is acc931a5

*api=eglInitialize

curr=ac708a64,it's address is acc93c9d

*api=eglTerminate

curr=ac708a68,it's address is acc93cdd

*api=eglGetConfigs

curr=ac708a6c,it's address is acc93d41

*api=eglChooseConfig

curr=ac708a70,it's address is acc9472d

*api=eglGetConfigAttrib

curr=ac708a74,it's address is acc94325

*api=eglCreateWindowSurface

curr=ac708a78,it's address is acc94689

*api=eglCreatePixmapSurface

curr=ac708a7c,it's address is acc945d5

*api=eglCreatePbufferSurface

curr=ac708a80,it's address is acc9451d

*api=eglDestroySurface

curr=ac708a84,it's address is acc93a1d

*api=eglQuerySurface

curr=ac708a88,it's address is acc94341

*api=eglCreateContext

curr=ac708a8c,it's address is acc9415d

*api=eglDestroyContext

curr=ac708a90,it's address is acc93d09

*api=eglMakeCurrent

curr=ac708a94,it's address is acc93a6d

*api=eglGetCurrentContext

curr=ac708a98,it's address is acc93055

*api=eglGetCurrentSurface

curr=ac708a9c,it's address is acc941a1

*api=eglGetCurrentDisplay

curr=ac708aa0,it's address is acc93061

*api=eglQueryContext

curr=ac708aa4,it's address is acc942ed

*api=eglWaitGL

curr=ac708aa8,it's address is acc9307d

*api=eglWaitNative

curr=ac708aac,it's address is acc93081

*api=eglSwapBuffers

curr=ac708ab0,it's address is acc93bf5

*api=eglCopyBuffers

curr=ac708ab4,it's address is acc93d71

*api=eglGetError

curr=ac708ab8,it's address is acc93125

*api=eglQueryString

curr=ac708abc,it's address is acc9373d

*api=eglGetProcAddress

curr=ac708ac0,it's address is acc930b1

*api=eglSurfaceAttrib

curr=ac708ac4,it's address is acc93d89

*api=eglBindTexImage

curr=ac708ac8,it's address is acc93da5

*api=eglReleaseTexImage

curr=ac708acc,it's address is acc93dc1

*api=eglSwapInterval

curr=ac708ad0,it's address is acc93ddd

*api=eglBindAPI

curr=ac708ad4,it's address is acc93df9

*api=eglQueryAPI

curr=ac708ad8,it's address is acc93085

*api=eglWaitClient

curr=ac708adc,it's address is acc930e5

*api=eglReleaseThread

curr=ac708ae0,it's address is acc9308d

*api=eglCreatePbufferFromClientBuffer

curr=ac708ae4,it's address is acc941e5

*api=eglLockSurfaceKHR

curr=ac708ae8,it's address is acc93091

*api=eglUnlockSurfaceKHR

curr=ac708aec,it's address is acc93095

*api=eglCreateImageKHR

curr=ac708af0,it's address is acc94201

*api=eglDestroyImageKHR

curr=ac708af4,it's address is acc93e15

*api=eglSetSwapRectangleANDROID

curr=ac708af8,it's address is acc93c51

*api=eglGetRenderBufferANDROID

curr=ac708afc,it's address is acc94125

egl_connection_t的第二个变量是一个指针数组，类型是gl_hooks_t，从名字可以看出，它指向的是一组函数指针。跟踪一下

struct gl_hooks_t {

    struct gl_t {

        #include "entries.in"

    } gl;

    struct gl_ext_t {

        void (*extensions[MAX_NUMBER_OF_GL_EXTENSIONS])(void);

    } ext;

};

这个entries.ini文件里全部是函数的一些原型。。

证明了猜想。

 

        cnx->hooks[GLESv1_INDEX] = &gHooks[GLESv1_INDEX][IMPL_SOFTWARE];

        cnx->hooks[GLESv2_INDEX] = &gHooks[GLESv2_INDEX][IMPL_SOFTWARE];

这里将egl_connecttion_t变量指向了全局的gHooks，这些函数指针从哪里赋值的呢？跟踪发现，是在LoadDriver时，也是从

libGLES_android.so中查找出GLESV1_CM和GLESV2两组函数来对其进行了赋值操作。

 

major和minor是版本号。

最后一个变量egl_t egl。这个变量非常重要。在load_driver中可以看到它的身影（通过loader：：open间接调用的）。

 

struct egl_t {

    #include "EGL/egl_entries.in"

};

egl_t中也是一组函数指针，其中包含了OpenGL ES中底层的实现。所以如果要实现硬件加速的话，这里面的函数都要实现。

 

 

 egl_t* egl = &cnx->egl;

__eglMustCastToProperFunctionPointerType* curr =

(__eglMustCastToProperFunctionPointerType*)egl;

char const * const * api = egl_names;

while (*api)

{

     char const * name = *api;

     __eglMustCastToProperFunctionPointerType f =

         (__eglMustCastToProperFunctionPointerType)dlsym(dso, name);

     if (f == NULL)

     {

         // couldn't find the entry-point, use eglGetProcAddress()

         f = getProcAddress(name);

         if (f == NULL)

         {

              f = (__eglMustCastToProperFunctionPointerType)0;

         }

     }

     *curr++ = f;

     api++;

}

上面的这些语句完成了将驱动（libGLES_android.so）中的函数地址赋值给了cnx->egl指向的egl_t结构。因此有了这些操作，下面

就可以通过egl_connection_t::egl来访问EGL中的一些底层的函数了，比如初始化等的操作。

 

要实现硬件加速，需要实现的是与libGLES_android.so对应的那些函数。android会自动完成对其的加载、初始化、调用。

上面的一大部分功能都是在loader::open中进行调用的，回到egl_init_drivers_locked函数中。

其在调用了loader::open函数完成了对libGLES_android.so中的库进行加载的操作之后，真正开始 初始化操作了，所以说上面的一大部分操作，其实都是一些预初始化，真正的初始化操作还没有开始。。。。

 

真正的初始化操作来自这里EGLDisplay dpy = cnx->egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);

通过刚才的分析，我们很容易知道，这个egl.eglGetDisplay函数到底要去哪里找。有bet。

我们上面打印出了

*api=eglGetDisplay

curr=ac708a60,it's address is acc931a5

这个东东在libGLES_android.so的源码里。

 

eglGetDisplay在内部的实现并不是通过返回值的方式进行传递的，而是用的全局变量。

 

eglGetDisplay完成的事情主要有，加载真正的OpenGL ES 的动态链接库文件，里面包含各种openGL的操作，这个函数库在libGLES_andorid.so中，加载动态链接库之后，会将其中的一些函数指针的值传递到全局的gEGLImpl中，通过这个全局的结构体，可以访问libGLES_android.so中的所有的函数。

 

下面分析应用程序中调用eglInitialize函数，会完成的操作。

eglInitialize

 

在这个函数中，主要调用了libGLES_android中的eglIniitalize函数，eglGetConfigs函数，获取配置信息。

3.5 使用OpenGL ES硬件加速功能的方法

使用硬件加速功能的OpenGL ES的方法。

1.修改Loader.cpp文件里的Loader：：loader函数，添加gConfig.add( entry_t(0, 1, "mmoid") );或者修改egl.cfg文件。此文件位于/system/lib/egl/下，如果不存在，可以自己动手新建。格式是“dpy impl tag”比如自己添加的硬件加速库是libGLES_mmoid.so,则需要在此文件里这样编写

0 1 mmoid

修改后腰重启才可生效。

现在已经可以使用硬件加速功能了。

Android2.3 中如何使用GPU硬件加速

1.名词解释

GPU：Graphic Processing Unit （图形处理器）

OpenGL：Open Graphic Library 定义了一个跨编程语言、跨平台的编程接口的规格，不同厂商会有不同的实现方法，它主要用于三维图象（二维的亦可）绘制。

SurfaceFlinger：Android中负责Surface之间叠加、混合操作的动态库

Skia：Android中的2D图形库

libagl：Android中通过软件方法实现的一套OpenGL动态库

libhgl：为区别libagl，自定义的一种叫法。特指GPU厂商提供的硬件实现的OpenGL

composition：特指SurfaceFlinger对各个Surface之间的叠加、混合操作

render：特指使用OpenGL动态库进行3D渲染

copybit:Android使用2D引擎来加速图形操作（主要是Surface之间的composition操作）的一种技术，对应着一个或几个动态库。

pmem：Android特有驱动，从linux内核中reserve物理连续内存，可以为2d、3d引擎、vpu等设备分配物理连续内存。

2 3D、2D引擎在Android中的使用方法

2.1 Android如何使用2D、3D引擎

Android在启动后，会在运行时根据配置文件加载OpenGL（libagl & libhgl）的实现，如果有libhgl实现，默认使用libhgl实现，否则使用libagl实现。

 

Android OpenGL动态库使用方法：

1. 判断是否含有egl.cfg文件，如果没有在加载libagl

2. 如果有egl.cfg文件，则解析egl.cfg文件，根据egl.cfg文件加载对应libhgl和libagl

3. 分别解析libagl和libhgl，获取libagl和libhgl中标准OpenGL函数的函数地址（函数指针）

4. 系统在执行过程中，会通过函数指针调用到libagl或者libhgl中去，从而实现图形的绘制。

 

OpenGL在Android中两个作用：

1. 用于Surface的composition操作。

         SurfaceFlinger会调用到OpenGL中，通过libagl或者libhgl做Surface的组合、叠加操作。

2. 用于图形图像的渲染

         Android framework会对OpenGL实现进行java层次的简单封装，在java应用程序中对OpenGL的调用最终会调用到libagl或者libhgl中去。

         很多第三方游戏、3D图库、某些launcher会使用OpenGL实现比较炫丽UI的特效。

Copybit在Android中的作用

Copybit在Android中主要用于Surface的composition操作。

Skia在Android中的作用

Skia是Android的2D图形库，用于绘制文字、几何图形、图像等。

Skia的设备后端：Raster、OpenGL、PDF

 

Skia是否支持硬件加速？

参考http://code.google.com/p/skia/wiki/FAQ

1. Skia子类SkCanvas

         由于所有的绘图操作都会通过SkCanvas子类，这些绘图可以重定向到不同的图形API。SkGLCanvas已经可以将绘图操作直接指向对OpenGL的调用。参考src/gl目录

2. 自定义存在瓶颈的调用

         Skia中的某些blit操作存在瓶颈，可以利用CPU的一些特性去重写这些操作。比如在ARMV7设备上可以使用NEON SIMD指令进行优化。参考src/opts目录

 

2.2 使用GPU硬件加速需要做的工作

1. Linux内核方面：

         1.1添加GPU驱动支持，以模块方式编译GPU驱动，Android启动时加载内核模块。

         1.2添加PMEM支持，预留内存供GPU使用

2. Android方面：

         2.1添加copybit HAL

我们使用copybit调用2D engine对surface composition进行硬件加速。这样可能会达到更大的性能提升效果（比起使用3D engine）。

         2.2修改gralloc

gralloc负责显存等的分配，以及对framebuffer操作。如果使用copybit，必须修改gralloc

         2.3修改libagl

如果使用copybit，必须修改libagl，对libagl做部分hack，使之能够调用到copybit。

         2.4修改surfaceflinger

          如果使用 copybit 可能需要做部分修改