5

I'm trying to implement off-screen rendering with OpenGL ES on Android. My ultimate goal is to improve performance of texture mapping which I do in plain java and Bitmap/int[] APIs. I tried pbuffer approach, similar to the sample code from a relevant forum thread. It shows rather low performance, glReadPixels call takes up to 50 ms on one device and up to 15 ms on another.

There is more modern approach using Frame Buffers. The code samples are rather complicated and I don't expect much faster transfer from Frame Buffer to Android's Bitmaps than it was with pbuffers. Am I right with my estimation?

The third approach is using pixmaps. If I understood the docs right they should utilize more sophisticated memory sharing between OpenGL and Dalvik's memory than plain copy. The problem is that relevant APIs aren't present in the Android SDK.

There is no eglCreateImageKHR and EGLImageKHR structure exposed in Java. All C++ examples I could find rely on them.

There is eglCreatePixmapSurface but I can't figure out how to use it from the docs. Probably it receives some kind of bitmap handle in the native_pixmap parameter, but I can't find any way to create such a handle. Searching for "eglCreatePixmapSurface android" leads only to problem reports.

My main question is: can I use pixmaps on Android from Java without writing native code? If I need to go native is there working code I can use to evaluate performance before diving deep into OpenGL?

CheatEx
  • 2,082
  • 2
  • 19
  • 28

1 Answers1

6

The best way to improve texture loading performance on Android is to use the EGL image extensions you sited and EGL_NATIVE_BUFFER_ANDROID with native code. I have a code example of that in this article. I measured major performance improvements with this approach.

Android has no support for Pixmaps and pbuffers do not work on Nvidia Tegra devices. You should use FBO-attached textures instead. That is the way the Android SurfaceTexture class is implemented.

If you need alpha textures, that is another reason to use native code. There is a compatibility problem between Bitmap and OpenGL ES with alpha textures.

Using hardware texture compression formats (ETC/PVR instead of PNG) and mipmaps improves the loading performance and quality of texture rendering a lot too, as discussed in this article.

The big problem is glReadPixels(). EGL_NATIVE_BUFFER_ANDROID only works for writing textures, not for reading them back to a Bitmap. Android's platform code uses glReadPixels() to implement TextureView.getBitmap() and it is very slow. The best solution is to not copy the texture to a Bitmap, but to display the rendered TextureView directly which avoids glReadPixels().

I have been working with OpenGL ES 2.0 and the situation may have been improved with 3.0.

ClayMontgomery
  • 2,786
  • 1
  • 15
  • 14
  • Hey ClayMontgomery, I am trying to use gpuimage-library for some image processing tasks. It works fine but when when large images are used then its slow. It uses glReadPixels in one of the methods to create bitmap and its the bottleneck. Any suggestions to make it faster. I am not at all experienced in opengl https://github.com/CyberAgent/android-gpuimage/blob/febdf4900b437b2069661fd371d5469196e26f18/library/src/jp/co/cyberagent/android/gpuimage/PixelBuffer.java#L194 – Gaurav Vashisth Sep 26 '14 at 14:35
  • The time for glReadPixels can be cut by about 30% by calling it from native code instead of Java because then you don't have to copy the image twice to get it into a Bitmap. But, the best solution is to avoid reading the image altogether and display it directly. – ClayMontgomery Sep 26 '14 at 15:20
  • Hello ClayMontgomery, I was writing a question for you here but I ended up creating a whole new [question](http://stackoverflow.com/questions/31264607/using-graphicbuffers-to-fast-read-from-a-texture). Would be grate if you could take a look at it. – focs Jul 07 '15 at 09:23