Android: Handle SurfaceTextureHelper ctor failure for decoder and capturer

webrtc/api/java/android/org/webrtc/VideoCapturerAndroid.java

 /*
  *  Copyright 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.webrtc;
 
 import android.content.Context;
+import android.graphics.SurfaceTexture;
+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.webrtc.CameraEnumerationAndroid.CaptureFormat;
 import org.webrtc.Logging;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.HashSet;
@@ skipping 45 matching lines @@
   private final Object pendingCameraSwitchLock = new Object();
   private volatile boolean pendingCameraSwitch;
   private CapturerObserver frameObserver = null;
   private final CameraEventsHandler eventsHandler;
   private boolean firstFrameReported;
   // Arbitrary queue depth.  Higher number means more memory allocated & held,
   // lower number means more sensitivity to processing time in the client (and
   // potentially stalling the capturer if it runs out of buffers to write to).
   private static final int NUMBER_OF_CAPTURE_BUFFERS = 3;
   private final Set<byte[]> queuedBuffers = new HashSet<byte[]>();
-  private final boolean isCapturingToTexture;
+  private boolean isCapturingToTexture;
   private SurfaceTextureHelper surfaceHelper;
+  // These dummy variables are used in case |surfaceHelper| is null.
+  private int dummyTextureId;
+  private SurfaceTexture dummySurfaceTexture;
   // 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;
   private final static int MAX_OPEN_CAMERA_ATTEMPTS = 3;
   private final static int OPEN_CAMERA_DELAY_MS = 500;
   private int openCameraAttempts;
 
   // Camera error callback.
   private final android.hardware.Camera.ErrorCallback cameraErrorCallback =
       new android.hardware.Camera.ErrorCallback() {
@@ skipping 20 matching lines @@
       int cameraFramesCount = cameraStatistics.getAndResetFrameCount();
       int cameraFps = (cameraFramesCount * 1000 + CAMERA_OBSERVER_PERIOD_MS / 2)
           / CAMERA_OBSERVER_PERIOD_MS;
 
       Logging.d(TAG, "Camera fps: " + cameraFps +".");
       if (cameraFramesCount == 0) {
         ++freezePeriodCount;
         if (CAMERA_OBSERVER_PERIOD_MS * freezePeriodCount >= CAMERA_FREEZE_REPORT_TIMOUT_MS
             && eventsHandler != null) {
           Logging.e(TAG, "Camera freezed.");
-          if (surfaceHelper.isTextureInUse()) {
+          if (surfaceHelper != null && surfaceHelper.isTextureInUse()) {
             // This can only happen if we are capturing to textures.
             eventsHandler.onCameraFreezed("Camera failure. Client must return video buffers.");
           } else {
             eventsHandler.onCameraFreezed("Camera failure.");
           }
           return;
         }
       } else {
         freezePeriodCount = 0;
       }
@@ skipping 234 matching lines @@
   }
 
   // Note that this actually opens the camera, and Camera callbacks run on the
   // thread that calls open(), so this is done on the CameraThread.
   @Override
   public void startCapture(
       final int width, final int height, final int framerate,
       final SurfaceTextureHelper surfaceTextureHelper, final Context applicationContext,
       final CapturerObserver frameObserver) {
     Logging.d(TAG, "startCapture requested: " + width + "x" + height + "@" + framerate);
-    if (surfaceTextureHelper == null) {
-      throw new IllegalArgumentException("surfaceTextureHelper not set.");
-    }
     if (applicationContext == null) {
       throw new IllegalArgumentException("applicationContext not set.");
     }
     if (frameObserver == null) {
       throw new IllegalArgumentException("frameObserver not set.");
     }
     synchronized (handlerLock) {
       if (this.cameraThreadHandler != null) {
         throw new RuntimeException("Camera has already been started.");
       }
-      this.cameraThreadHandler = surfaceTextureHelper.getHandler();
-      this.surfaceHelper = surfaceTextureHelper;
+      if (surfaceTextureHelper != null) {
+        this.cameraThreadHandler = surfaceTextureHelper.getHandler();
+        this.surfaceHelper = surfaceTextureHelper;
+      } else {
+        // No SurfaceTextureHelper - create own handler.
+        if (isCapturingToTexture) {
+          Logging.e(TAG, "No SurfaceTextureHelper - falling back to byte buffer capture");
+          isCapturingToTexture = false;
+        }
+        this.surfaceHelper = null;
+        final HandlerThread thread = new HandlerThread(TAG);
+        thread.start();
+        this.cameraThreadHandler = new Handler(thread.getLooper());
+      }
       final boolean didPost = maybePostOnCameraThread(new Runnable() {
         @Override
         public void run() {
           openCameraAttempts = 0;
           startCaptureOnCameraThread(width, height, framerate, frameObserver,
               applicationContext);
         }
       });
       if (!didPost) {
         frameObserver.onCapturerStarted(false);
@@ skipping 36 matching lines @@
               startCaptureOnCameraThread(width, height, framerate, frameObserver,
                   applicationContext);
             }
           });
           return;
         }
         throw e;
       }
 
       try {
-        camera.setPreviewTexture(surfaceHelper.getSurfaceTexture());
+        if (surfaceHelper != null) {
+          camera.setPreviewTexture(surfaceHelper.getSurfaceTexture());
+        } else {
+          // No SurfaceTextureHelper - create own dummy SurfaceTexture.
+          this.dummyTextureId = GlUtil.generateTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES);
+          this.dummySurfaceTexture = new SurfaceTexture(dummyTextureId);
+          camera.setPreviewTexture(dummySurfaceTexture);
+        }
       } 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);
-      if (isCapturingToTexture) {
+      if (isCapturingToTexture && surfaceHelper != null) {
         surfaceHelper.startListening(this);
       }
 
       // Start camera observer.
       maybePostDelayedOnCameraThread(CAMERA_OBSERVER_PERIOD_MS, cameraObserver);
       return;
     } catch (RuntimeException e) {
       error = e;
     }
     Logging.e(TAG, "startCapture failed", error);
     if (camera != null) {
       // Make sure the camera is released.
       stopCaptureOnCameraThread();
     }
     synchronized (handlerLock) {
       // Remove all pending Runnables posted from |this|.
       cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
+      releaseOwnHandlerAndDummySurfaceTexture();
       cameraThreadHandler = null;
     }
     frameObserver.onCapturerStarted(false);
     if (eventsHandler != null) {
       eventsHandler.onCameraError("Camera can not be started.");
     }
     return;
   }
 
+  private void releaseOwnHandlerAndDummySurfaceTexture() {
+    if (surfaceHelper == null) {
+      // We are using our own thread - quit it.
+      cameraThreadHandler.getLooper().quit();
+      cameraThreadHandler = null;
+    }
+    if (dummyTextureId != 0) {
+      GLES20.glDeleteTextures(1, new int[] {dummyTextureId}, 0);
+      dummyTextureId = 0;
+    }
+    if (dummySurfaceTexture != null) {
+      dummySurfaceTexture.release();
+      dummySurfaceTexture = null;
+    }
+  }
+
   // (Re)start preview with the closest supported format to |width| x |height| @ |framerate|.
   private void startPreviewOnCameraThread(int width, int height, int framerate) {
     checkIsOnCameraThread();
     Logging.d(
         TAG, "startPreviewOnCameraThread requested: " + width + "x" + height + "@" + framerate);
     if (camera == null) {
       Logging.e(TAG, "Calling startPreviewOnCameraThread on stopped camera.");
       return;
     }
 
@@ skipping 81 matching lines @@
   @Override
   public void stopCapture() throws InterruptedException {
     Logging.d(TAG, "stopCapture");
     final CountDownLatch barrier = new CountDownLatch(1);
     final boolean didPost = maybePostOnCameraThread(new Runnable() {
       @Override public void run() {
         stopCaptureOnCameraThread();
         synchronized (handlerLock) {
           // Remove all pending Runnables posted from |this|.
           cameraThreadHandler.removeCallbacksAndMessages(this /* token */);
+          releaseOwnHandlerAndDummySurfaceTexture();
           cameraThreadHandler = null;
           surfaceHelper = null;
         }
         barrier.countDown();
       }
     });
     if (!didPost) {
       Logging.e(TAG, "Calling stopCapture() for already stopped camera.");
       return;
     }
     if (!barrier.await(CAMERA_STOP_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
       Logging.e(TAG, "Camera stop timeout");
       printStackTrace();
       if (eventsHandler != null) {
         eventsHandler.onCameraError("Camera stop timeout");
       }
     }
     Logging.d(TAG, "stopCapture done");
   }
 
   private void stopCaptureOnCameraThread() {
     checkIsOnCameraThread();
     Logging.d(TAG, "stopCaptureOnCameraThread");
 
     // Make sure onTextureFrameAvailable() is not called anymore.
-    surfaceHelper.stopListening();
+    if (surfaceHelper != null) {
+      surfaceHelper.stopListening();
+    }
     cameraThreadHandler.removeCallbacks(cameraObserver);
     cameraStatistics.getAndResetFrameCount();
     Logging.d(TAG, "Stop preview.");
     camera.stopPreview();
     camera.setPreviewCallbackWithBuffer(null);
     queuedBuffers.clear();
     captureFormat = null;
 
     Logging.d(TAG, "Release camera.");
     camera.release();
@@ skipping 116 matching lines @@
       // Undo the mirror that the OS "helps" us with.
       // http://developer.android.com/reference/android/hardware/Camera.html#setDisplayOrientation(int)
       transformMatrix =
           RendererCommon.multiplyMatrices(transformMatrix, RendererCommon.horizontalFlipMatrix());
     }
     cameraStatistics.addFrame();
     frameObserver.onTextureFrameCaptured(captureFormat.width, captureFormat.height, oesTextureId,
         transformMatrix, rotation, timestampNs);
   }
 }