Android: Replace EGL14 with EGL10

talk/app/webrtc/java/android/org/webrtc/VideoCapturerAndroid.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 13 matching lines @@
  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 package org.webrtc;
 
 import android.content.Context;
 import android.graphics.SurfaceTexture;
 import android.hardware.Camera;
 import android.hardware.Camera.PreviewCallback;
-import android.opengl.EGLContext;
-import android.opengl.GLES11Ext;
-import android.opengl.GLES20;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.SystemClock;
 import android.view.Surface;
 import android.view.WindowManager;
 
 import org.json.JSONException;
 import org.webrtc.CameraEnumerationAndroid.CaptureFormat;
 import org.webrtc.Logging;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
+import javax.microedition.khronos.egl.EGLContext;
+import javax.microedition.khronos.egl.EGL10;
+
 // Android specific implementation of VideoCapturer.
 // An instance of this class can be created by an application using
 // VideoCapturerAndroid.create();
 // This class extends VideoCapturer with a method to easily switch between the
 // front and back camera. It also provides methods for enumerating valid device
 // names.
 //
 // Threading notes: this class is called from C++ code, Android Camera callbacks, and possibly
 // arbitrary Java threads. All public entry points are thread safe, and delegate the work to the
 // camera thread. The internal *OnCameraThread() methods must check |camera| for null to check if
@@ skipping 19 matching lines @@
   private int requestedHeight;
   private int requestedFramerate;
   // The capture format will be the closest supported format to the requested format.
   private CaptureFormat captureFormat;
   private final Object pendingCameraSwitchLock = new Object();
   private volatile boolean pendingCameraSwitch;
   private CapturerObserver frameObserver = null;
   private final CameraEventsHandler eventsHandler;
   private boolean firstFrameReported;
   private final boolean isCapturingToTexture;
-  // |cameraGlTexture| is used with setPreviewTexture if the capturer is capturing to
-  // ByteBuffers.
-  private int cameraGlTexture;
-  // |cameraSurfaceTexture| is used with setPreviewTexture if the capturer is capturing to
-  // ByteBuffers. Must be a member, see issue webrtc:5021.
-  private SurfaceTexture cameraSurfaceTexture;
-  //|surfaceHelper| is used if the capturer is capturing to a texture. Capturing to textures require
-  // API level 17.
   private final SurfaceTextureHelper surfaceHelper;
   // The camera API can output one old frame after the camera has been switched or the resolution
   // has been changed. This flag is used for dropping the first frame after camera restart.
   private boolean dropNextFrame = false;
 
   // Camera error callback.
   private final Camera.ErrorCallback cameraErrorCallback =
       new Camera.ErrorCallback() {
     @Override
     public void onError(int error, Camera camera) {
@@ skipping 101 matching lines @@
     // Invoked on failure, e.g. camera is stopped or only one camera available.
     void onCameraSwitchError(String errorDescription);
   }
 
   public static VideoCapturerAndroid create(String name,
       CameraEventsHandler eventsHandler) {
     return VideoCapturerAndroid.create(name, eventsHandler, null);
   }
 
   public static VideoCapturerAndroid create(String name,
-      CameraEventsHandler eventsHandler, Object sharedEglContext) {
+      CameraEventsHandler eventsHandler, EGLContext sharedEglContext) {
     final int cameraId = lookupDeviceName(name);
     if (cameraId == -1) {
       return null;
     }
 
     final VideoCapturerAndroid capturer = new VideoCapturerAndroid(cameraId, eventsHandler,
         sharedEglContext);
     capturer.setNativeCapturer(nativeCreateVideoCapturer(capturer));
     return capturer;
   }
@@ skipping 92 matching lines @@
   private String getSupportedFormatsAsJson() throws JSONException {
     return CameraEnumerationAndroid.getSupportedFormatsAsJson(getCurrentCameraId());
   }
 
   // Called from native VideoCapturer_nativeCreateVideoCapturer.
   private VideoCapturerAndroid(int cameraId) {
     this(cameraId, null, null);
   }
 
   private VideoCapturerAndroid(int cameraId, CameraEventsHandler eventsHandler,
-      Object sharedContext) {
+      EGLContext sharedContext) {
     Logging.d(TAG, "VideoCapturerAndroid");
     this.id = cameraId;
     this.eventsHandler = eventsHandler;
     cameraThread = new HandlerThread(TAG);
     cameraThread.start();
     cameraThreadHandler = new Handler(cameraThread.getLooper());
     videoBuffers = new FramePool(cameraThread);
-    if (sharedContext != null) {
-      surfaceHelper = SurfaceTextureHelper.create((EGLContext)sharedContext, cameraThreadHandler);
+    isCapturingToTexture = (sharedContext != null);
+    surfaceHelper = SurfaceTextureHelper.create(
+        isCapturingToTexture ? sharedContext : EGL10.EGL_NO_CONTEXT, cameraThreadHandler);
+    if (isCapturingToTexture) {
       surfaceHelper.setListener(this);
-      isCapturingToTexture = true;
-    } else {
-      surfaceHelper = null;
-      isCapturingToTexture = false;
     }
   }
 
   private void checkIsOnCameraThread() {
     if (Thread.currentThread() != cameraThread) {
       throw new IllegalStateException("Wrong thread");
     }
   }
 
   // Returns the camera index for camera with name |deviceName|, or -1 if no such camera can be
@@ skipping 25 matching lines @@
       @Override
       public void run() {
         if (camera != null) {
           throw new IllegalStateException("Release called while camera is running");
         }
         if (cameraStatistics.pendingFramesCount() != 0) {
           throw new IllegalStateException("Release called with pending frames left");
         }
       }
     });
-    if (isCapturingToTexture) {
-      surfaceHelper.disconnect();
-    }
+    surfaceHelper.disconnect();
     cameraThread.quit();
     ThreadUtils.joinUninterruptibly(cameraThread);
     cameraThread = null;
   }
 
   // Used for testing purposes to check if release() has been called.
   public boolean isReleased() {
     return (cameraThread == null);
   }
 
@@ skipping 35 matching lines @@
         Logging.d(TAG, "Opening camera " + id);
         firstFrameReported = false;
         if (eventsHandler != null) {
           eventsHandler.onCameraOpening(id);
         }
         camera = Camera.open(id);
         info = new Camera.CameraInfo();
         Camera.getCameraInfo(id, info);
       }
       try {
-        if (isCapturingToTexture) {
-          camera.setPreviewTexture(surfaceHelper.getSurfaceTexture());
-        } else {
-          cameraGlTexture = GlUtil.generateTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES);
-          cameraSurfaceTexture = new SurfaceTexture(cameraGlTexture);
-          camera.setPreviewTexture(cameraSurfaceTexture);
-        }
+        camera.setPreviewTexture(surfaceHelper.getSurfaceTexture());
       } catch (IOException e) {
         Logging.e(TAG, "setPreviewTexture failed", error);
         throw new RuntimeException(e);
       }
 
       Logging.d(TAG, "Camera orientation: " + info.orientation +
           " .Device orientation: " + getDeviceOrientation());
       camera.setErrorCallback(cameraErrorCallback);
       startPreviewOnCameraThread(width, height, framerate);
       frameObserver.onCapturerStarted(true);
@@ skipping 122 matching lines @@
                : " Pending buffers: " + cameraStatistics.pendingFramesTimeStamps() + "."));
     }
     captureFormat = null;
 
     Logging.d(TAG, "Release camera.");
     camera.release();
     camera = null;
     if (eventsHandler != null) {
       eventsHandler.onCameraClosed();
     }
-
-    if (cameraGlTexture != 0) {
-      GLES20.glDeleteTextures(1, new int[] {cameraGlTexture}, 0);
-      cameraGlTexture = 0;
-    }
-    if (cameraSurfaceTexture != null) {
-      cameraSurfaceTexture.release();
-    }
   }
 
   private void switchCameraOnCameraThread() {
     checkIsOnCameraThread();
     Logging.d(TAG, "switchCameraOnCameraThread");
     stopCaptureOnCameraThread();
     synchronized (cameraIdLock) {
       id = (id + 1) % Camera.getNumberOfCameras();
     }
     dropNextFrame = true;
@@ skipping 288 matching lines @@
     private native void nativeOnByteBufferFrameCaptured(long nativeCapturer,
         byte[] data, int length, int width, int height, int rotation, long timeStamp);
     private native void nativeOnTextureFrameCaptured(long nativeCapturer, int width, int height,
         int oesTextureId, float[] transformMatrix, long timestamp);
     private native void nativeOnOutputFormatRequest(long nativeCapturer,
         int width, int height, int framerate);
   }
 
   private static native long nativeCreateVideoCapturer(VideoCapturerAndroid videoCapturer);
 }