1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 package org.webrtc.videoengine; 12 13 import java.util.concurrent.locks.ReentrantLock; 14 15 import javax.microedition.khronos.egl.EGL10; 16 import javax.microedition.khronos.egl.EGLConfig; 17 import javax.microedition.khronos.egl.EGLContext; 18 import javax.microedition.khronos.egl.EGLDisplay; 19 import javax.microedition.khronos.opengles.GL10; 20 21 import android.app.ActivityManager; 22 import android.content.Context; 23 import android.content.pm.ConfigurationInfo; 24 import android.graphics.PixelFormat; 25 import android.opengl.GLSurfaceView; 26 27 import org.webrtc.Logging; 28 29 public class ViEAndroidGLES20 extends GLSurfaceView 30 implements GLSurfaceView.Renderer { 31 private static String TAG = "WEBRTC-JR"; 32 private static final boolean DEBUG = false; 33 // True if onSurfaceCreated has been called. 34 private boolean surfaceCreated = false; 35 private boolean openGLCreated = false; 36 // True if NativeFunctionsRegistered has been called. 37 private boolean nativeFunctionsRegisted = false; 38 private ReentrantLock nativeFunctionLock = new ReentrantLock(); 39 // Address of Native object that will do the drawing. 40 private long nativeObject = 0; 41 private int viewWidth = 0; 42 private int viewHeight = 0; 43 UseOpenGL2(Object renderWindow)44 public static boolean UseOpenGL2(Object renderWindow) { 45 return ViEAndroidGLES20.class.isInstance(renderWindow); 46 } 47 ViEAndroidGLES20(Context context)48 public ViEAndroidGLES20(Context context) { 49 super(context); 50 init(false, 0, 0); 51 } 52 ViEAndroidGLES20(Context context, boolean translucent, int depth, int stencil)53 public ViEAndroidGLES20(Context context, boolean translucent, 54 int depth, int stencil) { 55 super(context); 56 init(translucent, depth, stencil); 57 } 58 init(boolean translucent, int depth, int stencil)59 private void init(boolean translucent, int depth, int stencil) { 60 61 // By default, GLSurfaceView() creates a RGB_565 opaque surface. 62 // If we want a translucent one, we should change the surface's 63 // format here, using PixelFormat.TRANSLUCENT for GL Surfaces 64 // is interpreted as any 32-bit surface with alpha by SurfaceFlinger. 65 if (translucent) { 66 this.getHolder().setFormat(PixelFormat.TRANSLUCENT); 67 } 68 69 // Setup the context factory for 2.0 rendering. 70 // See ContextFactory class definition below 71 setEGLContextFactory(new ContextFactory()); 72 73 // We need to choose an EGLConfig that matches the format of 74 // our surface exactly. This is going to be done in our 75 // custom config chooser. See ConfigChooser class definition 76 // below. 77 setEGLConfigChooser( translucent ? 78 new ConfigChooser(8, 8, 8, 8, depth, stencil) : 79 new ConfigChooser(5, 6, 5, 0, depth, stencil) ); 80 81 // Set the renderer responsible for frame rendering 82 this.setRenderer(this); 83 this.setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY); 84 } 85 86 private static class ContextFactory implements GLSurfaceView.EGLContextFactory { 87 private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098; createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig)88 public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) { 89 Logging.w(TAG, "creating OpenGL ES 2.0 context"); 90 checkEglError("Before eglCreateContext", egl); 91 int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE }; 92 EGLContext context = egl.eglCreateContext(display, eglConfig, 93 EGL10.EGL_NO_CONTEXT, attrib_list); 94 checkEglError("After eglCreateContext", egl); 95 return context; 96 } 97 destroyContext(EGL10 egl, EGLDisplay display, EGLContext context)98 public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) { 99 egl.eglDestroyContext(display, context); 100 } 101 } 102 checkEglError(String prompt, EGL10 egl)103 private static void checkEglError(String prompt, EGL10 egl) { 104 int error; 105 while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) { 106 Logging.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error)); 107 } 108 } 109 110 private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser { 111 ConfigChooser(int r, int g, int b, int a, int depth, int stencil)112 public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) { 113 mRedSize = r; 114 mGreenSize = g; 115 mBlueSize = b; 116 mAlphaSize = a; 117 mDepthSize = depth; 118 mStencilSize = stencil; 119 } 120 121 // This EGL config specification is used to specify 2.0 rendering. 122 // We use a minimum size of 4 bits for red/green/blue, but will 123 // perform actual matching in chooseConfig() below. 124 private static int EGL_OPENGL_ES2_BIT = 4; 125 private static int[] s_configAttribs2 = 126 { 127 EGL10.EGL_RED_SIZE, 4, 128 EGL10.EGL_GREEN_SIZE, 4, 129 EGL10.EGL_BLUE_SIZE, 4, 130 EGL10.EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, 131 EGL10.EGL_NONE 132 }; 133 chooseConfig(EGL10 egl, EGLDisplay display)134 public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) { 135 136 // Get the number of minimally matching EGL configurations 137 int[] num_config = new int[1]; 138 egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config); 139 140 int numConfigs = num_config[0]; 141 142 if (numConfigs <= 0) { 143 throw new IllegalArgumentException("No configs match configSpec"); 144 } 145 146 // Allocate then read the array of minimally matching EGL configs 147 EGLConfig[] configs = new EGLConfig[numConfigs]; 148 egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config); 149 150 if (DEBUG) { 151 printConfigs(egl, display, configs); 152 } 153 // Now return the "best" one 154 return chooseConfig(egl, display, configs); 155 } 156 chooseConfig(EGL10 egl, EGLDisplay display, EGLConfig[] configs)157 public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display, 158 EGLConfig[] configs) { 159 for(EGLConfig config : configs) { 160 int d = findConfigAttrib(egl, display, config, 161 EGL10.EGL_DEPTH_SIZE, 0); 162 int s = findConfigAttrib(egl, display, config, 163 EGL10.EGL_STENCIL_SIZE, 0); 164 165 // We need at least mDepthSize and mStencilSize bits 166 if (d < mDepthSize || s < mStencilSize) 167 continue; 168 169 // We want an *exact* match for red/green/blue/alpha 170 int r = findConfigAttrib(egl, display, config, 171 EGL10.EGL_RED_SIZE, 0); 172 int g = findConfigAttrib(egl, display, config, 173 EGL10.EGL_GREEN_SIZE, 0); 174 int b = findConfigAttrib(egl, display, config, 175 EGL10.EGL_BLUE_SIZE, 0); 176 int a = findConfigAttrib(egl, display, config, 177 EGL10.EGL_ALPHA_SIZE, 0); 178 179 if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize) 180 return config; 181 } 182 return null; 183 } 184 findConfigAttrib(EGL10 egl, EGLDisplay display, EGLConfig config, int attribute, int defaultValue)185 private int findConfigAttrib(EGL10 egl, EGLDisplay display, 186 EGLConfig config, int attribute, int defaultValue) { 187 188 if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) { 189 return mValue[0]; 190 } 191 return defaultValue; 192 } 193 printConfigs(EGL10 egl, EGLDisplay display, EGLConfig[] configs)194 private void printConfigs(EGL10 egl, EGLDisplay display, 195 EGLConfig[] configs) { 196 int numConfigs = configs.length; 197 Logging.w(TAG, String.format("%d configurations", numConfigs)); 198 for (int i = 0; i < numConfigs; i++) { 199 Logging.w(TAG, String.format("Configuration %d:\n", i)); 200 printConfig(egl, display, configs[i]); 201 } 202 } 203 printConfig(EGL10 egl, EGLDisplay display, EGLConfig config)204 private void printConfig(EGL10 egl, EGLDisplay display, 205 EGLConfig config) { 206 int[] attributes = { 207 EGL10.EGL_BUFFER_SIZE, 208 EGL10.EGL_ALPHA_SIZE, 209 EGL10.EGL_BLUE_SIZE, 210 EGL10.EGL_GREEN_SIZE, 211 EGL10.EGL_RED_SIZE, 212 EGL10.EGL_DEPTH_SIZE, 213 EGL10.EGL_STENCIL_SIZE, 214 EGL10.EGL_CONFIG_CAVEAT, 215 EGL10.EGL_CONFIG_ID, 216 EGL10.EGL_LEVEL, 217 EGL10.EGL_MAX_PBUFFER_HEIGHT, 218 EGL10.EGL_MAX_PBUFFER_PIXELS, 219 EGL10.EGL_MAX_PBUFFER_WIDTH, 220 EGL10.EGL_NATIVE_RENDERABLE, 221 EGL10.EGL_NATIVE_VISUAL_ID, 222 EGL10.EGL_NATIVE_VISUAL_TYPE, 223 0x3030, // EGL10.EGL_PRESERVED_RESOURCES, 224 EGL10.EGL_SAMPLES, 225 EGL10.EGL_SAMPLE_BUFFERS, 226 EGL10.EGL_SURFACE_TYPE, 227 EGL10.EGL_TRANSPARENT_TYPE, 228 EGL10.EGL_TRANSPARENT_RED_VALUE, 229 EGL10.EGL_TRANSPARENT_GREEN_VALUE, 230 EGL10.EGL_TRANSPARENT_BLUE_VALUE, 231 0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB, 232 0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA, 233 0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL, 234 0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL, 235 EGL10.EGL_LUMINANCE_SIZE, 236 EGL10.EGL_ALPHA_MASK_SIZE, 237 EGL10.EGL_COLOR_BUFFER_TYPE, 238 EGL10.EGL_RENDERABLE_TYPE, 239 0x3042 // EGL10.EGL_CONFORMANT 240 }; 241 String[] names = { 242 "EGL_BUFFER_SIZE", 243 "EGL_ALPHA_SIZE", 244 "EGL_BLUE_SIZE", 245 "EGL_GREEN_SIZE", 246 "EGL_RED_SIZE", 247 "EGL_DEPTH_SIZE", 248 "EGL_STENCIL_SIZE", 249 "EGL_CONFIG_CAVEAT", 250 "EGL_CONFIG_ID", 251 "EGL_LEVEL", 252 "EGL_MAX_PBUFFER_HEIGHT", 253 "EGL_MAX_PBUFFER_PIXELS", 254 "EGL_MAX_PBUFFER_WIDTH", 255 "EGL_NATIVE_RENDERABLE", 256 "EGL_NATIVE_VISUAL_ID", 257 "EGL_NATIVE_VISUAL_TYPE", 258 "EGL_PRESERVED_RESOURCES", 259 "EGL_SAMPLES", 260 "EGL_SAMPLE_BUFFERS", 261 "EGL_SURFACE_TYPE", 262 "EGL_TRANSPARENT_TYPE", 263 "EGL_TRANSPARENT_RED_VALUE", 264 "EGL_TRANSPARENT_GREEN_VALUE", 265 "EGL_TRANSPARENT_BLUE_VALUE", 266 "EGL_BIND_TO_TEXTURE_RGB", 267 "EGL_BIND_TO_TEXTURE_RGBA", 268 "EGL_MIN_SWAP_INTERVAL", 269 "EGL_MAX_SWAP_INTERVAL", 270 "EGL_LUMINANCE_SIZE", 271 "EGL_ALPHA_MASK_SIZE", 272 "EGL_COLOR_BUFFER_TYPE", 273 "EGL_RENDERABLE_TYPE", 274 "EGL_CONFORMANT" 275 }; 276 int[] value = new int[1]; 277 for (int i = 0; i < attributes.length; i++) { 278 int attribute = attributes[i]; 279 String name = names[i]; 280 if (egl.eglGetConfigAttrib(display, config, attribute, value)) { 281 Logging.w(TAG, String.format(" %s: %d\n", name, value[0])); 282 } else { 283 // Logging.w(TAG, String.format(" %s: failed\n", name)); 284 while (egl.eglGetError() != EGL10.EGL_SUCCESS); 285 } 286 } 287 } 288 289 // Subclasses can adjust these values: 290 protected int mRedSize; 291 protected int mGreenSize; 292 protected int mBlueSize; 293 protected int mAlphaSize; 294 protected int mDepthSize; 295 protected int mStencilSize; 296 private int[] mValue = new int[1]; 297 } 298 299 // IsSupported 300 // Return true if this device support Open GL ES 2.0 rendering. IsSupported(Context context)301 public static boolean IsSupported(Context context) { 302 ActivityManager am = 303 (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); 304 ConfigurationInfo info = am.getDeviceConfigurationInfo(); 305 if(info.reqGlEsVersion >= 0x20000) { 306 // Open GL ES 2.0 is supported. 307 return true; 308 } 309 return false; 310 } 311 onDrawFrame(GL10 gl)312 public void onDrawFrame(GL10 gl) { 313 nativeFunctionLock.lock(); 314 if(!nativeFunctionsRegisted || !surfaceCreated) { 315 nativeFunctionLock.unlock(); 316 return; 317 } 318 319 if(!openGLCreated) { 320 if(0 != CreateOpenGLNative(nativeObject, viewWidth, viewHeight)) { 321 return; // Failed to create OpenGL 322 } 323 openGLCreated = true; // Created OpenGL successfully 324 } 325 DrawNative(nativeObject); // Draw the new frame 326 nativeFunctionLock.unlock(); 327 } 328 onSurfaceChanged(GL10 gl, int width, int height)329 public void onSurfaceChanged(GL10 gl, int width, int height) { 330 surfaceCreated = true; 331 viewWidth = width; 332 viewHeight = height; 333 334 nativeFunctionLock.lock(); 335 if(nativeFunctionsRegisted) { 336 if(CreateOpenGLNative(nativeObject,width,height) == 0) 337 openGLCreated = true; 338 } 339 nativeFunctionLock.unlock(); 340 } 341 onSurfaceCreated(GL10 gl, EGLConfig config)342 public void onSurfaceCreated(GL10 gl, EGLConfig config) { 343 } 344 RegisterNativeObject(long nativeObject)345 public void RegisterNativeObject(long nativeObject) { 346 nativeFunctionLock.lock(); 347 this.nativeObject = nativeObject; 348 nativeFunctionsRegisted = true; 349 nativeFunctionLock.unlock(); 350 } 351 DeRegisterNativeObject()352 public void DeRegisterNativeObject() { 353 nativeFunctionLock.lock(); 354 nativeFunctionsRegisted = false; 355 openGLCreated = false; 356 this.nativeObject = 0; 357 nativeFunctionLock.unlock(); 358 } 359 ReDraw()360 public void ReDraw() { 361 if(surfaceCreated) { 362 // Request the renderer to redraw using the render thread context. 363 this.requestRender(); 364 } 365 } 366 CreateOpenGLNative(long nativeObject, int width, int height)367 private native int CreateOpenGLNative(long nativeObject, 368 int width, int height); DrawNative(long nativeObject)369 private native void DrawNative(long nativeObject); 370 371 } 372