Use EGL14 if supported on Android

talk/app/webrtc/java/android/org/webrtc/EglBase.java

 /*
  * libjingle
  * Copyright 2015 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 16 matching lines @@
 
 package org.webrtc;
 
 import android.graphics.Canvas;
 import android.graphics.SurfaceTexture;
 import android.graphics.Rect;
 import android.view.Surface;
 import android.view.SurfaceHolder;
 
 import org.webrtc.Logging;
+import org.webrtc.EglBase.ConfigType;
+import org.webrtc.EglBase.Context;
 
 import javax.microedition.khronos.egl.EGL10;
 import javax.microedition.khronos.egl.EGLConfig;
 import javax.microedition.khronos.egl.EGLContext;
 import javax.microedition.khronos.egl.EGLDisplay;
 import javax.microedition.khronos.egl.EGLSurface;
 
 /**
- * Holds EGL state and utility methods for handling an EGLContext, an EGLDisplay, and an EGLSurface.
+ * Holds EGL state and utility methods for handling an egl 1.0 EGLContext, an EGLDisplay,
+ * and an EGLSurface.
  */
 public class EglBase {
   private static final String TAG = "EglBase";
   // These constants are taken from EGL14.EGL_OPENGL_ES2_BIT and EGL14.EGL_CONTEXT_CLIENT_VERSION.
   // https://android.googlesource.com/platform/frameworks/base/+/master/opengl/java/android/opengl/EGL14.java
   // This is similar to how GlSurfaceView does:
   // http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/5.1.1_r1/android/opengl/GLSurfaceView.java#760
   private static final int EGL_OPENGL_ES2_BIT = 4;
   private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
   // Android-specific extension.
   private static final int EGL_RECORDABLE_ANDROID = 0x3142;
 
   private final EGL10 egl;
   private EGLContext eglContext;
   private ConfigType configType;
   private EGLConfig eglConfig;
   private EGLDisplay eglDisplay;
   private EGLSurface eglSurface = EGL10.EGL_NO_SURFACE;
 
+  // EGL wrapper for an actual EGLContext.
+  public static class Context {
+    private final EGLContext eglContext;
+
+    public Context(EGLContext eglContext) {
+      this.eglContext = eglContext;
+    }
+  }
+
   // EGLConfig constructor type. Influences eglChooseConfig arguments.
   public static enum ConfigType {
     // No special parameters.
     PLAIN,
     // Configures with EGL_SURFACE_TYPE = EGL_PBUFFER_BIT.
     PIXEL_BUFFER,
     // Configures with EGL_RECORDABLE_ANDROID = 1.
     // Discourages EGL from using pixel formats that cannot efficiently be
     // converted to something usable by the video encoder.
     RECORDABLE
   }
 
-  // Create root context without any EGLSurface or parent EGLContext. This can be used for branching
+  // Create a new context with the specified config type, sharing data with sharedContext.
+  // |sharedContext| can be null.
+  public static EglBase create(Context sharedContext, ConfigType configType) {
+    return (EglBase14.isEGL14Supported()
+        && (sharedContext == null || sharedContext instanceof EglBase14.Context))
+            ? new EglBase14((EglBase14.Context) sharedContext, configType)
+            : new EglBase(sharedContext, configType);
+  }
+
+  public static EglBase create() {
+    return create(null, ConfigType.PLAIN);
+  }
+
+  //Create root context without any EGLSurface or parent EGLContext. This can be used for branching
   // new contexts that share data.
+  @Deprecated
   public EglBase() {
-    this(EGL10.EGL_NO_CONTEXT, ConfigType.PLAIN);
+    this((Context) null, ConfigType.PLAIN);
+  }
+
+  @Deprecated
+  public EglBase(EGLContext sharedContext, ConfigType configType) {
+    this(new Context(sharedContext), configType);
+    Logging.d(TAG, "EglBase created");
+  }
+
+  @Deprecated
+  public EGLContext getContext() {
+    return eglContext;
   }
 
   // Create a new context with the specified config type, sharing data with sharedContext.
-  public EglBase(EGLContext sharedContext, ConfigType configType) {
+  EglBase(Context sharedContext, ConfigType configType) {
     this.egl = (EGL10) EGLContext.getEGL();
     this.configType = configType;
     eglDisplay = getEglDisplay();
     eglConfig = getEglConfig(eglDisplay, configType);
     eglContext = createEglContext(sharedContext, eglDisplay, eglConfig);
   }
 
-  // Create EGLSurface from the Android Surface.
+  // TODO(perkj): This is a hacky ctor used to allow us to create an EGLBase14. Remove this and
+  // make EglBase an abstract class once all applications have started using the create factory
+  // method.
+  protected EglBase(boolean dummy) {
+    this.egl = null;
+  }
+
   public void createSurface(Surface surface) {
     /**
      * We have to wrap Surface in a SurfaceHolder because for some reason eglCreateWindowSurface
      * couldn't actually take a Surface object until API 17. Older versions fortunately just call
      * SurfaceHolder.getSurface(), so we'll do that. No other methods are relevant.
      */
     class FakeSurfaceHolder implements SurfaceHolder {
       private final Surface surface;
 
       FakeSurfaceHolder(Surface surface) {
         this.surface = surface;
       }
 
       @Override
       public void addCallback(Callback callback) {}
 
       @Override
       public void removeCallback(Callback callback) {}
 
       @Override
       public boolean isCreating() {
         return false;
       }
 
+      @Deprecated
       @Override
       public void setType(int i) {}
 
       @Override
       public void setFixedSize(int i, int i2) {}
 
       @Override
       public void setSizeFromLayout() {}
 
       @Override
@@ skipping 67 matching lines @@
     if (eglSurface != EGL10.EGL_NO_SURFACE) {
       throw new RuntimeException("Already has an EGLSurface");
     }
     int[] surfaceAttribs = {EGL10.EGL_WIDTH, width, EGL10.EGL_HEIGHT, height, EGL10.EGL_NONE};
     eglSurface = egl.eglCreatePbufferSurface(eglDisplay, eglConfig, surfaceAttribs);
     if (eglSurface == EGL10.EGL_NO_SURFACE) {
       throw new RuntimeException("Failed to create pixel buffer surface");
     }
   }
 
-  public EGLContext getContext() {
-    return eglContext;
+  public Context getEglBaseContext() {
+    return new Context(eglContext);
   }
 
   public boolean hasSurface() {
     return eglSurface != EGL10.EGL_NO_SURFACE;
   }
 
   public int surfaceWidth() {
     final int widthArray[] = new int[1];
     egl.eglQuerySurface(eglDisplay, eglSurface, EGL10.EGL_WIDTH, widthArray);
     return widthArray[0];
@@ skipping 101 matching lines @@
     int[] numConfigs = new int[1];
     if (!egl.eglChooseConfig(
         eglDisplay, configAttributes, configs, configs.length, numConfigs)) {
       throw new RuntimeException("Unable to find RGB888 " + configType + " EGL config");
     }
     return configs[0];
   }
 
   // Return an EGLConfig, or die trying.
   private EGLContext createEglContext(
-      EGLContext sharedContext, EGLDisplay eglDisplay, EGLConfig eglConfig) {
+      Context sharedContext, EGLDisplay eglDisplay, EGLConfig eglConfig) {
     int[] contextAttributes = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE};
+    EGLContext rootContext =
+        sharedContext == null ? EGL10.EGL_NO_CONTEXT : sharedContext.eglContext;
     EGLContext eglContext =
-        egl.eglCreateContext(eglDisplay, eglConfig, sharedContext, contextAttributes);
+        egl.eglCreateContext(eglDisplay, eglConfig, rootContext, contextAttributes);
     if (eglContext == EGL10.EGL_NO_CONTEXT) {
       throw new RuntimeException("Failed to create EGL context");
     }
     return eglContext;
   }
 }