1
2
3
4
5

adb root
adb remount
adb shell
cd system/priv-app/xxx
rm -rf *

1
2
3
4
5

adb root
adb remount
adb shell
mkdir testViewport
adb push TestViewport /system/app/testViewport

1

adb shell am start -n com.android.test/.TestActivity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

adb push test-opengl-configdump/test-opengl-configdump  /data/nativetest64/
adb shell
cd /data/nativetest64/
chmod 0777 test-opengl-configdump
./test-opengl-configdumpEGLConfig[0]EGL_BUFFER_SIZE                 :         16 (0x00000010)EGL_ALPHA_SIZE                  :          0 (0x00000000)EGL_BLUE_SIZE                   :          5 (0x00000005)EGL_GREEN_SIZE                  :          6 (0x00000006)EGL_RED_SIZE                    :          5 (0x00000005)EGL_DEPTH_SIZE                  :          0 (0x00000000)EGL_STENCIL_SIZE                :          0 (0x00000000)EGL_CONFIG_CAVEAT               :      12344 (0x00003038)EGL_CONFIG_ID                   :          1 (0x00000001)EGL_LEVEL                       :          0 (0x00000000)EGL_MAX_PBUFFER_HEIGHT          :      16384 (0x00004000)EGL_MAX_PBUFFER_WIDTH           :      16384 (0x00004000)EGL_MAX_PBUFFER_PIXELS          :  268435456 (0x10000000)EGL_NATIVE_RENDERABLE           :          1 (0x00000001)EGL_NATIVE_VISUAL_ID            :          4 (0x00000004)EGL_NATIVE_VISUAL_TYPE          :         -1 (0xffffffff)EGL_SAMPLES                     :          0 (0x00000000)EGL_SAMPLE_BUFFERS              :          0 (0x00000000)EGL_SURFACE_TYPE                :       5541 (0x000015a5)EGL_TRANSPARENT_TYPE            :      12344 (0x00003038)EGL_TRANSPARENT_BLUE_VALUE      :         -1 (0xffffffff)EGL_TRANSPARENT_GREEN_VALUE     :         -1 (0xffffffff)EGL_TRANSPARENT_RED_VALUE       :         -1 (0xffffffff)EGL_BIND_TO_TEXTURE_RGB         :          1 (0x00000001)EGL_BIND_TO_TEXTURE_RGBA        :          0 (0x00000000)EGL_MIN_SWAP_INTERVAL           :          0 (0x00000000)EGL_MAX_SWAP_INTERVAL           :          1 (0x00000001)EGL_LUMINANCE_SIZE              :          0 (0x00000000)EGL_ALPHA_MASK_SIZE             :          0 (0x00000000)EGL_COLOR_BUFFER_TYPE           :      12430 (0x0000308e)EGL_RENDERABLE_TYPE             :         69 (0x00000045)EGL_MATCH_NATIVE_PIXMAP         :          0 (0x00000000)EGL_CONFORMANT                  :         69 (0x00000045)EGL_COLOR_COMPONENT_TYPE_EXT    :      13114 (0x0000333a)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#include <stdlib.h>
#include <stdio.h>#include <EGL/egl.h>
#include <EGL/eglext.h>#define ATTRIBUTE(_attr) { _attr, #_attr }struct Attribute {EGLint attribute;char const* name;
};// clang-format off
Attribute attributes[] = {ATTRIBUTE( EGL_BUFFER_SIZE ),ATTRIBUTE( EGL_ALPHA_SIZE ),ATTRIBUTE( EGL_BLUE_SIZE ),ATTRIBUTE( EGL_GREEN_SIZE ),ATTRIBUTE( EGL_RED_SIZE ),ATTRIBUTE( EGL_DEPTH_SIZE ),ATTRIBUTE( EGL_STENCIL_SIZE ),ATTRIBUTE( EGL_CONFIG_CAVEAT ),ATTRIBUTE( EGL_CONFIG_ID ),ATTRIBUTE( EGL_LEVEL ),ATTRIBUTE( EGL_MAX_PBUFFER_HEIGHT ),ATTRIBUTE( EGL_MAX_PBUFFER_WIDTH ),ATTRIBUTE( EGL_MAX_PBUFFER_PIXELS ),ATTRIBUTE( EGL_NATIVE_RENDERABLE ),ATTRIBUTE( EGL_NATIVE_VISUAL_ID ),ATTRIBUTE( EGL_NATIVE_VISUAL_TYPE ),ATTRIBUTE( EGL_SAMPLES ),ATTRIBUTE( EGL_SAMPLE_BUFFERS ),ATTRIBUTE( EGL_SURFACE_TYPE ),ATTRIBUTE( EGL_TRANSPARENT_TYPE ),ATTRIBUTE( EGL_TRANSPARENT_BLUE_VALUE ),ATTRIBUTE( EGL_TRANSPARENT_GREEN_VALUE ),ATTRIBUTE( EGL_TRANSPARENT_RED_VALUE ),ATTRIBUTE( EGL_BIND_TO_TEXTURE_RGB ),ATTRIBUTE( EGL_BIND_TO_TEXTURE_RGBA ),ATTRIBUTE( EGL_MIN_SWAP_INTERVAL ),ATTRIBUTE( EGL_MAX_SWAP_INTERVAL ),ATTRIBUTE( EGL_LUMINANCE_SIZE ),ATTRIBUTE( EGL_ALPHA_MASK_SIZE ),ATTRIBUTE( EGL_COLOR_BUFFER_TYPE ),ATTRIBUTE( EGL_RENDERABLE_TYPE ),ATTRIBUTE( EGL_MATCH_NATIVE_PIXMAP ),ATTRIBUTE( EGL_CONFORMANT ),ATTRIBUTE( EGL_COLOR_COMPONENT_TYPE_EXT ),
};
// clang-format onint main(int /*argc*/, char** /*argv*/) {EGLConfig* configs;EGLint n;EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);eglInitialize(dpy, 0, 0);eglGetConfigs(dpy, NULL, 0, &n);configs = new EGLConfig[n];eglGetConfigs(dpy, configs, n, &n);for (EGLint i=0 ; i<n ; i++) {printf("EGLConfig[%d]\n", i);for (unsigned attr = 0 ; attr<sizeof(attributes)/sizeof(Attribute) ; attr++) {EGLint value;eglGetConfigAttrib(dpy, configs[i], attributes[attr].attribute, &value);printf("\t%-32s: %10d (0x%08x)\n", attributes[attr].name, value, value);}}delete [] configs;eglTerminate(dpy);return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

EGL_SUCCESS：没有错误
EGL_NOT_INITIALIZED：没有初始化
EGL_BAD_ACCESS：数据访问失败
EGL_BAD_ALLOC：内存分配失败
EGL_BAD_ATTRIBUTE：错误的属性
EGL_BAD_CONFIG：错误的配置
EGL_BAD_CONTEXT：错误的上下文
EGL_BAD_CURRENT_SURFACE：当前Surface对象错误
EGL_BAD_DISPLAY：错误的设备对象
EGL_BAD_MATCH：无法匹配
EGL_BAD_NATIVE_PIXMAP：错误的像素图
EGL_BAD_NATIVE_WINDOW：错误的本地窗口对象
EGL_BAD_PARAMETER：错误的参数
EGL_BAD_SURFACE：错误的Surface对象
EGL_CONTEXT_LOST：上下文丢失

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

EGL_ALPHA_SIZE：颜色缓冲区中的透明度分量的位数
EGL_ALPHA_MASK_SIZE：透明度掩码位数
EGL_BUFFER_SIZE：颜色缓冲区中颜色分量的位数
EGL_BLUE_SIZE：颜色缓冲区中的蓝色分量的位数
EGL_BIND_TO_TEXTURE_RGB：是否可以绑定RGB纹理
EGL_BIND_TO_TEXTURE_RGBA：是否可以绑定EGBA纹理
EGL_CONFIG_CAVEAT：注意事项
EGL_COLOR_BUFFER_TYPE：颜色缓冲区类型
EGL_CONFORMANT：创建的上下文是否兼容
EGL_CONFIG_ID：配置信息ID
EGL_DEPTH_SIZE：深度缓冲区位数
EGL_GREEN_SIZE：颜色缓冲区中的绿色分量的位数
EGL_LEVEL：帧缓冲区级别
EGL_LUMINANCE_SIZE：颜色缓冲区亮度位数
EGL_MAX_PBUFFER_HEIGHT：Pbuffer的最大高度
EGL_MAX_PBUFFER_PIXELS：Pbuffer的最大尺寸
EGL_MAX_PBUFFER_WIDTH：Pbuffer的最大宽度
EGL_MATCH_NATIVE_PIXMAP
EGL_MIN_SWAP_INTERVAL：最小缓冲区交换间隔
EGL_MAX_SWAP_INTERVAL：最大缓冲区交换间隔
EGL_NATIVE_RENDERABLE：是否可用原生渲染库渲染
EGL_NONE
EGL_NATIVE_VISUAL_ID：原生窗口系统的可视ID
EGL_NATIVE_VISUAL_TYPE：原生窗口系统的可视类型
EGL_RED_SIZE：颜色缓冲区中的红色分量的位数
EGL_RENDERABLE_TYPE：可渲染接口类型
EGL_STENCIL_SIZE：模板缓冲区位数
EGL_SAMPLES：每个像素的样本数量
EGL_SAMPLE_BUFFERS：可用多重采样缓冲区数量
EGL_SURFACE_TYPE：EGL表面类型
EGL_TRANSPARENT_TYPE：透明度类型
EGL_TRANSPARENT_BLUE_VALUE：透明的蓝色值
EGL_TRANSPARENT_GREEN_VALUE：透明的绿色值
EGL_TRANSPARENT_RED_VALUE：透明的红色值
显示设备对象
EGL_NO_DISPLAY：当前无可用设备
显示设备类型
EGL_DEFAULT_DISPLAY：默认为当前使用设备

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

EGLConfig config;
EGLint numConfigs = 0;
EGLint attribList[] ={EGL_RENDERABLE_TYPE, EGL_OPENGL_ES_BIT,EGL_RED_SIZE, 8,EGL_GREEN_SIZE, 8,EGL_BLUE_SIZE, 8,EGL_ALPHA_SIZE, 8,EGL_DEPTH_SIZE, 16,EGL_NONE};
if (!eglChooseConfig(context->eglDisplay, attribList, &config, 1, &numConfigs)) {return GL_FALSE;
}

1
2
3
4
5

EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE};
context->eglContext = eglCreateContext(context->eglDisplay, config, EGL_NO_CONTEXT, contextAttribs);
if (context->eglContext == EGL_NO_CONTEXT) {return GL_FALSE;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

context->eglSurface = eglCreateWindowSurface(context->eglDisplay, config, context->nativeWindow,NULL);if (context->eglSurface == EGL_NO_SURFACE) {EGLint error;while((error = eglGetError()) != EGL_SUCCESS){switch(error) {case EGL_BAD_MATCH:{//提供的原生窗口不匹配或者不支持渲染}case EGL_BAD_CONFIG:{//系统不支持该配置}case EGL_BAD_NATIVE_WINDOW:{//提供的原生窗口无效}case EGL_BAD_ALLOC:{//无法为新的EGL分配资源或者该窗口已经被关联}}}}

1
2
3
4
5
6
7
8
9
10
11
12

EGLint majorVersion;
EGLint minorVersion;
EGLDisplay display;
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
if(display == EGL_NO_DISPLAY)
{// Unable to open connection to local windowing system
}
if(!eglInitialize(display, &majorVersion, &minorVersion))
{// Unable to initialize EGL. Handle and recover
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// we need this config
EGLint attribList[] ={
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_RED_SIZE, 5,
EGL_GREEN_SIZE, 6,
EGL_BLUE_SIZE, 5,
EGL_DEPTH_SIZE, 1,
EGL_NONE
};
const EGLint MaxConfigs = 10;
EGLConfig configs[MaxConfigs]; // We'll only accept 10 configs
EGLint numConfigs;
if(!eglChooseConfig(dpy, attribList, configs, MaxConfigs,
&numConfigs))
{
// Something didn't work … handle error situation
}
else
{
// Everything's okay. Continue to create a rendering surface
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

EGLRenderSurface window;
EGLint attribList[] =
{EGL_RENDER_BUFFER, EGL_BACK_BUFFER,EGL_NONE
);
window = eglCreateWindowSurface(dpy, config, window, attribList);
if(window == EGL_NO_SURFACE)
{
switch(eglGetError())
{case EGL_BAD_MATCH:// Check window and EGLConfig attributes to determine// compatibility, or verify that the EGLConfig// supports rendering to a window,break;case EGL_BAD_CONFIG:// Verify that provided EGLConfig is validbreak;case EGL_BAD_NATIVE_WINDOW:// Verify that provided EGLNativeWindow is validbreak;case EGL_BAD_ALLOC:// Not enough resources available. Handle and recoverbreak;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

const ELGint attribList[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,EGL_NONE
};
EGLContext context;
context = eglCreateContext(dpy, config, EGL_NO_CONTEXT, attribList);
if(context == EGL_NO_CONTEXT)
{EGLError error = eglGetError();if(error == EGL_BAD_CONFIG){// Handle error and recover}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

EGLDisplay eglDisplay;EGLSurface eglSurface;EGLContext eglContext;GLuint texture;int main(int argc, char **argv){int q;int start, end;printf("Initializing EGL...\n");WindowSurface windowSurface;if(!init_gl_surface(windowSurface)){printf("GL initialisation failed - exiting\n");return 0;}init_scene();create_texture();printf("Start test...\n");render(argc==2 ? atoi(argv[1]) : ITERATIONS);free_gl_surface();return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

int init_gl_surface(const WindowSurface& windowSurface)
{EGLint numConfigs = 1;EGLConfig myConfig = {0};EGLint attrib[] ={EGL_SURFACE_TYPE, EGL_WINDOW_BIT,EGL_DEPTH_SIZE,     16,EGL_NONE};//建立本地窗口系统和OpenGL ES的连接if ( (eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY ){printf("eglGetDisplay failed\n");return 0;}//使用函数eglInitialize进行初始化操作if ( eglInitialize(eglDisplay, NULL, NULL) != EGL_TRUE ){printf("eglInitialize failed\n");return 0;}//根据EGLNativeWindowType 选择ConfigEGLNativeWindowType window = windowSurface.getSurface();EGLUtils::selectConfigForNativeWindow(eglDisplay, attrib, window, &myConfig);//创建渲染表面if ( (eglSurface = eglCreateWindowSurface(eglDisplay, myConfig,window, 0)) == EGL_NO_SURFACE ){printf("eglCreateWindowSurface failed\n");return 0;}//创建渲染上下文if ( (eglContext = eglCreateContext(eglDisplay, myConfig, 0, 0)) == EGL_NO_CONTEXT ){printf("eglCreateContext failed\n");return 0;}//进行当前上下文的绑定if ( eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext) != EGL_TRUE ){printf("eglMakeCurrent failed\n");return 0;}return 1;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

void init_scene(void)
{glDisable(GL_DITHER);glEnable(GL_CULL_FACE);float ratio = 320.0f / 480.0f;glViewport(0, 0, 320, 480);//设置视区尺寸glMatrixMode(GL_PROJECTION);glLoadIdentity();glFrustumf(-ratio, ratio, -1, 1, 1, 10);//使用一个透视矩阵乘以当前矩阵glMatrixMode(GL_MODELVIEW);glLoadIdentity();//重置投影矩阵gluLookAt(0, 0, 3,  // eye0, 0, 0,  // center0, 1, 0); // upglEnable(GL_TEXTURE_2D);glEnableClientState(GL_VERTEX_ARRAY);glEnableClientState(GL_TEXTURE_COORD_ARRAY);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

void create_texture(void)
{const unsigned int on = 0xff0000ff;const unsigned int off = 0xffffffff;const unsigned int pixels[] ={on, off, on, off, on, off, on, off,off, on, off, on, off, on, off, on,on, off, on, off, on, off, on, off,off, on, off, on, off, on, off, on,on, off, on, off, on, off, on, off,off, on, off, on, off, on, off, on,on, off, on, off, on, off, on, off,off, on, off, on, off, on, off, on,};glGenTextures(1, &texture);glBindTexture(GL_TEXTURE_2D, texture);glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 8, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

void render(int quads)
{int i, j;const GLfloat vertices[] = {-1,  -1,  0,1,  -1,  0,1,   1,  0,-1,   1,  0};const GLfixed texCoords[] = {0,            0,FIXED_ONE,    0,FIXED_ONE,    FIXED_ONE,0,            FIXED_ONE};const GLushort quadIndices[] = { 0, 1, 2,  0, 2, 3 };GLushort* indices = (GLushort*)malloc(quads*sizeof(quadIndices));for (i=0 ; i<quads ; i++)memcpy(indices+(sizeof(quadIndices)/sizeof(indices[0]))*i, quadIndices, sizeof(quadIndices));glVertexPointer(3, GL_FLOAT, 0, vertices);glTexCoordPointer(2, GL_FIXED, 0, texCoords);// make sure to do a couple eglSwapBuffers to make sure there are// no problems with the very first ones (who knows)glClearColor(0.4, 0.4, 0.4, 0.4);glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);eglSwapBuffers(eglDisplay, eglSurface);glClearColor(0.6, 0.6, 0.6, 0.6);glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);eglSwapBuffers(eglDisplay, eglSurface);glClearColor(1.0, 1.0, 1.0, 1.0);for (j=0 ; j<10 ; j++) {printf("loop %d / 10 (%d quads / loop)\n", j, quads);int nelem = sizeof(quadIndices)/sizeof(quadIndices[0]);glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);glDrawElements(GL_TRIANGLES, nelem*quads, GL_UNSIGNED_SHORT, indices);eglSwapBuffers(eglDisplay, eglSurface);}free(indices);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

#include <stdlib.h>
#include <stdio.h>#include <EGL/egl.h>
#include <GLES/gl.h>
#include <GLES/glext.h>#include <WindowSurface.h>
#include <EGLUtils.h>using namespace android;int main(int /*argc*/, char** /*argv*/)
{EGLint configAttribs[] = {EGL_DEPTH_SIZE, 0,EGL_NONE};EGLint majorVersion;EGLint minorVersion;EGLContext context;EGLConfig config;EGLSurface surface;EGLint w, h;EGLDisplay dpy;WindowSurface windowSurface;EGLNativeWindowType window = windowSurface.getSurface();dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);eglInitialize(dpy, &majorVersion, &minorVersion);status_t err = EGLUtils::selectConfigForNativeWindow(dpy, configAttribs, window, &config);if (err) {fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");return 0;}surface = eglCreateWindowSurface(dpy, config, window, NULL);context = eglCreateContext(dpy, config, NULL, NULL);eglMakeCurrent(dpy, surface, surface, context);   eglQuerySurface(dpy, surface, EGL_WIDTH, &w);eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);GLint dim = w<h ? w : h;GLint crop[4] = { 0, 4, 4, -4 };glBindTexture(GL_TEXTURE_2D, 0);glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);glEnable(GL_TEXTURE_2D);glColor4f(1,1,1,1);// packing is always 4uint8_t t8[]  = { 0x00, 0x55, 0x00, 0x55, 0xAA, 0xFF, 0xAA, 0xFF,0x00, 0x55, 0x00, 0x55, 0xAA, 0xFF, 0xAA, 0xFF  };uint16_t t16[]  = { 0x0000, 0x5555, 0x0000, 0x5555, 0xAAAA, 0xFFFF, 0xAAAA, 0xFFFF,0x0000, 0x5555, 0x0000, 0x5555, 0xAAAA, 0xFFFF, 0xAAAA, 0xFFFF  };uint16_t t5551[]  = { 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000,0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000  };uint32_t t32[]  = { 0xFF000000, 0xFF0000FF, 0xFF00FF00, 0xFFFF0000, 0xFF00FF00, 0xFFFF0000, 0xFF000000, 0xFF0000FF, 0xFF00FFFF, 0xFF00FF00, 0x00FF00FF, 0xFFFFFF00, 0xFF000000, 0xFFFF00FF, 0xFF00FFFF, 0xFFFFFFFF};glClear(GL_COLOR_BUFFER_BIT);glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 4, 4, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, t8);glDrawTexiOES(0, 0, 0, dim/2, dim/2);glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 4, 4, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, t16);glDrawTexiOES(dim/2, 0, 0, dim/2, dim/2);glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, t16);glDrawTexiOES(0, dim/2, 0, dim/2, dim/2);glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, t32);glDrawTexiOES(dim/2, dim/2, 0, dim/2, dim/2);eglSwapBuffers(dpy, surface);sleep(2);      // so you have a chance to admire itreturn 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

#define LOG_TAG "fillrate"#include <stdlib.h>
#include <stdio.h>#include <EGL/egl.h>
#include <GLES/gl.h>
#include <GLES/glext.h>#include <utils/StopWatch.h>
#include <WindowSurface.h>
#include <EGLUtils.h>using namespace android;int main(int /*argc*/, char** /*argv*/)
{EGLint configAttribs[] = {EGL_DEPTH_SIZE, 0,EGL_NONE};EGLint majorVersion;EGLint minorVersion;EGLContext context;EGLConfig config;EGLSurface surface;EGLint w, h;EGLDisplay dpy;WindowSurface windowSurface;EGLNativeWindowType window = windowSurface.getSurface();dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);eglInitialize(dpy, &majorVersion, &minorVersion);status_t err = EGLUtils::selectConfigForNativeWindow(dpy, configAttribs, window, &config);if (err) {fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");return 0;}surface = eglCreateWindowSurface(dpy, config, window, NULL);context = eglCreateContext(dpy, config, NULL, NULL);eglMakeCurrent(dpy, surface, surface, context);   eglQuerySurface(dpy, surface, EGL_WIDTH, &w);eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);printf("w=%d, h=%d\n", w, h);glBindTexture(GL_TEXTURE_2D, 0);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);glDisable(GL_DITHER);glEnable(GL_BLEND);glEnable(GL_TEXTURE_2D);glColor4f(1,1,1,1);uint32_t* t32 = (uint32_t*)malloc(512*512*4); for (int y=0 ; y<512 ; y++) {for (int x=0 ; x<512 ; x++) {int u = x-256;int v = y-256;if (u*u+v*v < 256*256) {t32[x+y*512] = 0x10FFFFFF;} else {t32[x+y*512] = 0x20FF0000;}}}const GLfloat fh = h;const GLfloat fw = w;const GLfloat vertices[4][2] = {{ 0,   0  },{ 0,   fh },{ fw,  fh },{ fw,  0  }};const GLfloat texCoords[4][2] = {{ 0,  0 },{ 0,  1 },{ 1,  1 },{ 1,  0 }};glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 512, 512, 0, GL_RGBA, GL_UNSIGNED_BYTE, t32);glViewport(0, 0, w, h);glMatrixMode(GL_PROJECTION);glLoadIdentity();glOrthof(0, w, 0, h, 0, 1);glEnableClientState(GL_VERTEX_ARRAY);glEnableClientState(GL_TEXTURE_COORD_ARRAY);glVertexPointer(2, GL_FLOAT, 0, vertices);glTexCoordPointer(2, GL_FLOAT, 0, texCoords);eglSwapInterval(dpy, 1);glClearColor(1,0,0,0);glClear(GL_COLOR_BUFFER_BIT);glDrawArrays(GL_TRIANGLE_FAN, 0, 4); eglSwapBuffers(dpy, surface);nsecs_t times[32];for (int c=1 ; c<32 ; c++) {glClear(GL_COLOR_BUFFER_BIT);for (int i=0 ; i<c ; i++) {glDrawArrays(GL_TRIANGLE_FAN, 0, 4); }eglSwapBuffers(dpy, surface);}//     for (int c=31 ; c>=1 ; c--) {int j=0;for (int c=1 ; c<32 ; c++) {glClear(GL_COLOR_BUFFER_BIT);nsecs_t now = systemTime();for (int i=0 ; i<c ; i++) {glDrawArrays(GL_TRIANGLE_FAN, 0, 4); }eglSwapBuffers(dpy, surface);nsecs_t t = systemTime() - now;times[j++] = t;}for (int c=1, j=0 ; c<32 ; c++, j++) {nsecs_t t = times[j];printf("%ld\t%d\t%f\n", t, c, (double(t)/c)/1000000.0);}eglTerminate(dpy);return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

#include <stdlib.h>
#include <stdio.h>#include <EGL/egl.h>
#include <GLES/gl.h>
#include <GLES/glext.h>#include <WindowSurface.h>
#include <EGLUtils.h>using namespace android;#define USE_DRAW_TEXTURE 1int main(int argc, char** argv)
{if (argc!=2 && argc!=3) {printf("usage: %s <0-6> [pbuffer]\n", argv[0]);return 0;}const int test = atoi(argv[1]);int usePbuffer = argc==3 && !strcmp(argv[2], "pbuffer");EGLint s_configAttribs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT|EGL_WINDOW_BIT,EGL_RED_SIZE,       5,EGL_GREEN_SIZE,     6,EGL_BLUE_SIZE,      5,EGL_NONE};EGLint numConfigs = -1;EGLint majorVersion;EGLint minorVersion;EGLConfig config;EGLContext context;EGLSurface surface;EGLint w, h;EGLDisplay dpy;EGLNativeWindowType window = 0;WindowSurface* windowSurface = NULL;if (!usePbuffer) {windowSurface = new WindowSurface();window = windowSurface->getSurface();}dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);eglInitialize(dpy, &majorVersion, &minorVersion);if (!usePbuffer) {EGLUtils::selectConfigForNativeWindow(dpy, s_configAttribs, window, &config);surface = eglCreateWindowSurface(dpy, config, window, NULL);} else {printf("using pbuffer\n");eglChooseConfig(dpy, s_configAttribs, &config, 1, &numConfigs);EGLint attribs[] = { EGL_WIDTH, 320, EGL_HEIGHT, 480, EGL_NONE };surface = eglCreatePbufferSurface(dpy, config, attribs);if (surface == EGL_NO_SURFACE) {printf("eglCreatePbufferSurface error %x\n", eglGetError());}}context = eglCreateContext(dpy, config, NULL, NULL);eglMakeCurrent(dpy, surface, surface, context);   eglQuerySurface(dpy, surface, EGL_WIDTH, &w);eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);GLint dim = w<h ? w : h;glViewport(0, 0, w, h);glMatrixMode(GL_PROJECTION);glLoadIdentity();glOrthof(0, w, 0, h, 0, 1);glClearColor(0,0,0,0);glClear(GL_COLOR_BUFFER_BIT);GLint crop[4] = { 0, 4, 4, -4 };glBindTexture(GL_TEXTURE_2D, 0);glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);glEnable(GL_TEXTURE_2D);glColor4f(1,1,1,1);// packing is always 4uint8_t t8[]  = { 0x00, 0x55, 0x00, 0x55, 0xAA, 0xFF, 0xAA, 0xFF,0x00, 0x55, 0x00, 0x55, 0xAA, 0xFF, 0xAA, 0xFF  };uint16_t t16[]  = { 0x0000, 0x5555, 0x0000, 0x5555, 0xAAAA, 0xFFFF, 0xAAAA, 0xFFFF,0x0000, 0x5555, 0x0000, 0x5555, 0xAAAA, 0xFFFF, 0xAAAA, 0xFFFF  };uint16_t t5551[]  = { 0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000,0x0000, 0xFFFF, 0x0000, 0xFFFF, 0xFFFF, 0x0000, 0xFFFF, 0x0000  };uint32_t t32[]  = { 0xFF000000, 0xFF0000FF, 0xFF00FF00, 0xFFFF0000, 0xFF00FF00, 0xFFFF0000, 0xFF000000, 0xFF0000FF, 0xFF00FFFF, 0xFF00FF00, 0x00FF00FF, 0xFFFFFF00, 0xFF000000, 0xFFFF00FF, 0xFF00FFFF, 0xFFFFFFFF};switch(test) {case 1:glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE,4, 4, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, t8);break;case 2:glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,4, 4, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, t16);break;case 3:glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, t16);break;case 4:glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,4, 4, 0, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, t16);break;case 5:glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, t5551);break;case 6:glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE, t32);break;}//glDrawTexiOES(0, 0, 0, dim, dim);const GLfloat fdim = dim;const GLfloat vertices[4][2] = {{ 0,     0    },{ 0,     fdim },{ fdim,  fdim },{ fdim,  0    }};const GLfloat texCoords[4][2] = {{ 0,  0 },{ 0,  1 },{ 1,  1 },{ 1,  0 }};if (!usePbuffer) {eglSwapBuffers(dpy, surface);}glMatrixMode(GL_MODELVIEW);glScissor(0,dim,dim,h-dim);glDisable(GL_SCISSOR_TEST);for (int y=0 ; y<dim ; y++) {//glDisable(GL_SCISSOR_TEST);glClear(GL_COLOR_BUFFER_BIT);//glEnable(GL_SCISSOR_TEST);#if USE_DRAW_TEXTURE && GL_OES_draw_textureglDrawTexiOES(0, y, 1, dim, dim);
#elseglLoadIdentity();glTranslatef(0, y, 0);glEnableClientState(GL_VERTEX_ARRAY);glEnableClientState(GL_TEXTURE_COORD_ARRAY);glVertexPointer(2, GL_FLOAT, 0, vertices);glTexCoordPointer(2, GL_FLOAT, 0, texCoords);glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
#endifif (!usePbuffer) {eglSwapBuffers(dpy, surface);} else {glFinish();}}eglTerminate(dpy);delete windowSurface;return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <sys/resource.h>#include <EGL/egl.h>
#include <GLES/gl.h>
#include <GLES/glext.h>#include <utils/Timers.h>#include <WindowSurface.h>
#include <EGLUtils.h>using namespace android;int main(int /*argc*/, char** /*argv*/)
{EGLint configAttribs[] = {EGL_DEPTH_SIZE, 0,EGL_NONE};EGLint majorVersion;EGLint minorVersion;EGLContext context;EGLConfig config;EGLSurface surface;EGLint w, h;EGLDisplay dpy;WindowSurface windowSurface;EGLNativeWindowType window = windowSurface.getSurface();dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);eglInitialize(dpy, &majorVersion, &minorVersion);status_t err = EGLUtils::selectConfigForNativeWindow(dpy, configAttribs, window, &config);if (err) {fprintf(stderr, "couldn't find an EGLConfig matching the screen format\n");return 0;}surface = eglCreateWindowSurface(dpy, config, window, NULL);context = eglCreateContext(dpy, config, NULL, NULL);eglMakeCurrent(dpy, surface, surface, context);   eglQuerySurface(dpy, surface, EGL_WIDTH, &w);eglQuerySurface(dpy, surface, EGL_HEIGHT, &h);GLint dim = w<h ? w : h;glBindTexture(GL_TEXTURE_2D, 0);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);glEnable(GL_TEXTURE_2D);glColor4f(1,1,1,1);glDisable(GL_DITHER);glShadeModel(GL_FLAT);long long now, t;int i;char* texels = (char*)malloc(512*512*2);memset(texels,0xFF,512*512*2);glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,512, 512, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, texels);char* dst = (char*)malloc(320*480*2);memset(dst, 0, 320*480*2);printf("307200 bytes memcpy\n");for (i=0 ; i<4 ; i++) {now = systemTime();memcpy(dst, texels, 320*480*2);t = systemTime();printf("memcpy() time = %llu us\n", (t-now)/1000);fflush(stdout);}free(dst);free(texels);setpriority(PRIO_PROCESS, 0, -20);printf("512x512 unmodified texture, 512x512 blit:\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {GLint crop[4] = { 0, 512, 512, -512 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);now = systemTime();glDrawTexiOES(0, 0, 0, 512, 512);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}printf("512x512 unmodified texture, 1x1 blit:\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {GLint crop[4] = { 0, 1, 1, -1 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);now = systemTime();glDrawTexiOES(0, 0, 0, 1, 1);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}printf("512x512 unmodified texture, 512x512 blit (x2):\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {GLint crop[4] = { 0, 512, 512, -512 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);now = systemTime();glDrawTexiOES(0, 0, 0, 512, 512);glDrawTexiOES(0, 0, 0, 512, 512);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}printf("512x512 unmodified texture, 1x1 blit (x2):\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {GLint crop[4] = { 0, 1, 1, -1 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);now = systemTime();glDrawTexiOES(0, 0, 0, 1, 1);glDrawTexiOES(0, 0, 0, 1, 1);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}printf("512x512 (1x1 texel MODIFIED texture), 512x512 blit:\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {uint16_t green = 0x7E0;GLint crop[4] = { 0, 512, 512, -512 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, &green);now = systemTime();glDrawTexiOES(0, 0, 0, 512, 512);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}int16_t texel = 0xF800;glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,1, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, &texel);printf("1x1 unmodified texture, 1x1 blit:\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {GLint crop[4] = { 0, 1, 1, -1 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);now = systemTime();glDrawTexiOES(0, 0, 0, 1, 1);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);eglSwapBuffers(dpy, surface);}printf("1x1 unmodified texture, 512x512 blit:\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {GLint crop[4] = { 0, 1, 1, -1 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);now = systemTime();glDrawTexiOES(0, 0, 0, 512, 512);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}printf("1x1 (1x1 texel MODIFIED texture), 512x512 blit:\n");glClear(GL_COLOR_BUFFER_BIT);for (i=0 ; i<4 ; i++) {uint16_t green = 0x7E0;GLint crop[4] = { 0, 1, 1, -1 };glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES, crop);glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1, 1, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, &green);now = systemTime();glDrawTexiOES(0, 0, 0, 1, 1);glFinish();t = systemTime();printf("glFinish() time = %llu us\n", (t-now)/1000);fflush(stdout);eglSwapBuffers(dpy, surface);}return 0;
}