Support for video file instead of camera and output video out to file

webrtc/examples/androidapp/src/org/appspot/apprtc/CallActivity.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.
  */
 
@@ skipping 11 matching lines @@
 import android.content.pm.PackageManager;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
 import android.util.Log;
 import android.view.View;
 import android.view.Window;
 import android.view.WindowManager.LayoutParams;
 import android.widget.Toast;
 
+import java.io.IOException;
+import java.lang.RuntimeException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.webrtc.Camera1Enumerator;
 import org.webrtc.Camera2Enumerator;
+import org.webrtc.CameraEnumerator;
 import org.webrtc.EglBase;
+import org.webrtc.FileVideoCapturer;
+import org.webrtc.VideoFileRenderer;
 import org.webrtc.IceCandidate;
+import org.webrtc.Logging;
 import org.webrtc.PeerConnectionFactory;
 import org.webrtc.RendererCommon.ScalingType;
 import org.webrtc.SessionDescription;
 import org.webrtc.StatsReport;
 import org.webrtc.SurfaceViewRenderer;
+import org.webrtc.VideoCapturer;
+import org.webrtc.VideoRenderer;
 
 /**
  * Activity for peer connection call setup, call waiting
  * and call view.
  */
 public class CallActivity extends Activity implements AppRTCClient.SignalingEvents,
                                                       PeerConnectionClient.PeerConnectionEvents,
                                                       CallFragment.OnCallEvents {
   public static final String EXTRA_ROOMID = "org.appspot.apprtc.ROOMID";
   public static final String EXTRA_LOOPBACK = "org.appspot.apprtc.LOOPBACK";
@@ skipping 15 matching lines @@
   public static final String EXTRA_AECDUMP_ENABLED = "org.appspot.apprtc.AECDUMP";
   public static final String EXTRA_OPENSLES_ENABLED = "org.appspot.apprtc.OPENSLES";
   public static final String EXTRA_DISABLE_BUILT_IN_AEC = "org.appspot.apprtc.DISABLE_BUILT_IN_AEC";
   public static final String EXTRA_DISABLE_BUILT_IN_AGC = "org.appspot.apprtc.DISABLE_BUILT_IN_AGC";
   public static final String EXTRA_DISABLE_BUILT_IN_NS = "org.appspot.apprtc.DISABLE_BUILT_IN_NS";
   public static final String EXTRA_ENABLE_LEVEL_CONTROL = "org.appspot.apprtc.ENABLE_LEVEL_CONTROL";
   public static final String EXTRA_DISPLAY_HUD = "org.appspot.apprtc.DISPLAY_HUD";
   public static final String EXTRA_TRACING = "org.appspot.apprtc.TRACING";
   public static final String EXTRA_CMDLINE = "org.appspot.apprtc.CMDLINE";
   public static final String EXTRA_RUNTIME = "org.appspot.apprtc.RUNTIME";
+  public static final String EXTRA_VIDEO_FILE_AS_CAMERA = "org.appspot.apprtc.VIDEO_FILE_AS_CAMERA";
+  public static final String EXTRA_SAVE_REMOTE_VIDEO_TO_FILE =
+      "org.appspot.apprtc.SAVE_REMOTE_VIDEO_TO_FILE";
+  public static final String EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH =
+      "org.appspot.apprtc.SAVE_REMOTE_VIDEO_TO_FILE_WIDTH";
+  public static final String EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT =
+      "org.appspot.apprtc.SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT";
+  public static final String EXTRA_USE_VALUES_FROM_INTENT =
+      "org.appspot.apprtc.USE_VALUES_FROM_INTENT";
   private static final String TAG = "CallRTCClient";
 
   // List of mandatory application permissions.
   private static final String[] MANDATORY_PERMISSIONS = {"android.permission.MODIFY_AUDIO_SETTINGS",
       "android.permission.RECORD_AUDIO", "android.permission.INTERNET"};
 
   // Peer connection statistics callback period in ms.
   private static final int STAT_CALLBACK_PERIOD = 1000;
   // Local preview screen position before call is connected.
   private static final int LOCAL_X_CONNECTING = 0;
   private static final int LOCAL_Y_CONNECTING = 0;
   private static final int LOCAL_WIDTH_CONNECTING = 100;
   private static final int LOCAL_HEIGHT_CONNECTING = 100;
   // Local preview screen position after call is connected.
   private static final int LOCAL_X_CONNECTED = 72;
   private static final int LOCAL_Y_CONNECTED = 72;
   private static final int LOCAL_WIDTH_CONNECTED = 25;
   private static final int LOCAL_HEIGHT_CONNECTED = 25;
   // Remote video screen position
   private static final int REMOTE_X = 0;
   private static final int REMOTE_Y = 0;
   private static final int REMOTE_WIDTH = 100;
   private static final int REMOTE_HEIGHT = 100;
   private PeerConnectionClient peerConnectionClient = null;
   private AppRTCClient appRtcClient;
   private SignalingParameters signalingParameters;
   private AppRTCAudioManager audioManager = null;
   private EglBase rootEglBase;
   private SurfaceViewRenderer localRender;
-  private SurfaceViewRenderer remoteRender;
+  private SurfaceViewRenderer remoteRenderScreen;
+  private VideoFileRenderer videoFileRenderer;
+  private final List<VideoRenderer.Callbacks> remoteRenderers =
+      new ArrayList<VideoRenderer.Callbacks>();
   private PercentFrameLayout localRenderLayout;
   private PercentFrameLayout remoteRenderLayout;
   private ScalingType scalingType;
   private Toast logToast;
   private boolean commandLineRun;
   private int runTimeMs;
   private boolean activityRunning;
   private RoomConnectionParameters roomConnectionParameters;
   private PeerConnectionParameters peerConnectionParameters;
   private boolean iceConnected;
@@ skipping 21 matching lines @@
     getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
         | View.SYSTEM_UI_FLAG_FULLSCREEN | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
     setContentView(R.layout.activity_call);
 
     iceConnected = false;
     signalingParameters = null;
     scalingType = ScalingType.SCALE_ASPECT_FILL;
 
     // Create UI controls.
     localRender = (SurfaceViewRenderer) findViewById(R.id.local_video_view);
-    remoteRender = (SurfaceViewRenderer) findViewById(R.id.remote_video_view);
+    remoteRenderScreen = (SurfaceViewRenderer) findViewById(R.id.remote_video_view);
     localRenderLayout = (PercentFrameLayout) findViewById(R.id.local_video_layout);
     remoteRenderLayout = (PercentFrameLayout) findViewById(R.id.remote_video_layout);
     callFragment = new CallFragment();
     hudFragment = new HudFragment();
 
     // Show/hide call control fragment on view click.
     View.OnClickListener listener = new View.OnClickListener() {
       @Override
       public void onClick(View view) {
         toggleCallControlFragmentVisibility();
       }
     };
 
     localRender.setOnClickListener(listener);
-    remoteRender.setOnClickListener(listener);
+    remoteRenderScreen.setOnClickListener(listener);
+    remoteRenderers.add(remoteRenderScreen);
+
+    final Intent intent = getIntent();
 
     // Create video renderers.
     rootEglBase = EglBase.create();
     localRender.init(rootEglBase.getEglBaseContext(), null);
-    remoteRender.init(rootEglBase.getEglBaseContext(), null);
+    String saveRemoteVideoToFile = intent.getStringExtra(EXTRA_SAVE_REMOTE_VIDEO_TO_FILE);
+
+    // When saveRemoteVideoToFile is set we save the video from the remote to a file.
+    if (saveRemoteVideoToFile != null) {
+      int videoOutWidth = intent.getIntExtra(EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_WIDTH, 0);
+      int videoOutHeight = intent.getIntExtra(EXTRA_SAVE_REMOTE_VIDEO_TO_FILE_HEIGHT, 0);
+      try {
+        videoFileRenderer = new VideoFileRenderer(
+            saveRemoteVideoToFile, videoOutWidth, videoOutHeight, rootEglBase.getEglBaseContext());
+        remoteRenderers.add(videoFileRenderer);
+      } catch (IOException e) {
+        throw new RuntimeException(
+            "Failed to open video file for output: " + saveRemoteVideoToFile, e);
+      }
+    }
+    remoteRenderScreen.init(rootEglBase.getEglBaseContext(), null);
+
     localRender.setZOrderMediaOverlay(true);
     updateVideoView();
 
     // Check for mandatory permissions.
     for (String permission : MANDATORY_PERMISSIONS) {
       if (checkCallingOrSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
         logAndToast("Permission " + permission + " is not granted");
         setResult(RESULT_CANCELED);
         finish();
         return;
       }
     }
 
-    // Get Intent parameters.
-    final Intent intent = getIntent();
     Uri roomUri = intent.getData();
     if (roomUri == null) {
       logAndToast(getString(R.string.missing_url));
       Log.e(TAG, "Didn't get any URL in intent!");
       setResult(RESULT_CANCELED);
       finish();
       return;
     }
+
+    // Get Intent parameters.
     String roomId = intent.getStringExtra(EXTRA_ROOMID);
+    Log.d(TAG, "Room ID: " + roomId);
     if (roomId == null || roomId.length() == 0) {
       logAndToast(getString(R.string.missing_url));
       Log.e(TAG, "Incorrect room ID in intent!");
       setResult(RESULT_CANCELED);
       finish();
       return;
     }
 
     boolean loopback = intent.getBooleanExtra(EXTRA_LOOPBACK, false);
     boolean tracing = intent.getBooleanExtra(EXTRA_TRACING, false);
 
-    boolean useCamera2 =
-        Camera2Enumerator.isSupported(this) && intent.getBooleanExtra(EXTRA_CAMERA2, true);
-
     peerConnectionParameters =
         new PeerConnectionParameters(intent.getBooleanExtra(EXTRA_VIDEO_CALL, true), loopback,
-            tracing, useCamera2, intent.getIntExtra(EXTRA_VIDEO_WIDTH, 0),
+            tracing, intent.getIntExtra(EXTRA_VIDEO_WIDTH, 0),
             intent.getIntExtra(EXTRA_VIDEO_HEIGHT, 0), intent.getIntExtra(EXTRA_VIDEO_FPS, 0),
             intent.getIntExtra(EXTRA_VIDEO_BITRATE, 0), intent.getStringExtra(EXTRA_VIDEOCODEC),
             intent.getBooleanExtra(EXTRA_HWCODEC_ENABLED, true),
-            intent.getBooleanExtra(EXTRA_CAPTURETOTEXTURE_ENABLED, false),
             intent.getIntExtra(EXTRA_AUDIO_BITRATE, 0), intent.getStringExtra(EXTRA_AUDIOCODEC),
             intent.getBooleanExtra(EXTRA_NOAUDIOPROCESSING_ENABLED, false),
             intent.getBooleanExtra(EXTRA_AECDUMP_ENABLED, false),
             intent.getBooleanExtra(EXTRA_OPENSLES_ENABLED, false),
             intent.getBooleanExtra(EXTRA_DISABLE_BUILT_IN_AEC, false),
             intent.getBooleanExtra(EXTRA_DISABLE_BUILT_IN_AGC, false),
             intent.getBooleanExtra(EXTRA_DISABLE_BUILT_IN_NS, false),
             intent.getBooleanExtra(EXTRA_ENABLE_LEVEL_CONTROL, false));
     commandLineRun = intent.getBooleanExtra(EXTRA_CMDLINE, false);
     runTimeMs = intent.getIntExtra(EXTRA_RUNTIME, 0);
 
+    Log.d(TAG, "VIDEO_FILE: '" + intent.getStringExtra(EXTRA_VIDEO_FILE_AS_CAMERA) + "'");
+
     // Create connection client. Use DirectRTCClient if room name is an IP otherwise use the
     // standard WebSocketRTCClient.
     if (loopback || !DirectRTCClient.IP_PATTERN.matcher(roomId).matches()) {
       appRtcClient = new WebSocketRTCClient(this);
     } else {
       Log.i(TAG, "Using DirectRTCClient because room name looks like an IP.");
       appRtcClient = new DirectRTCClient(this);
     }
     // Create connection parameters.
     roomConnectionParameters = new RoomConnectionParameters(roomUri.toString(), roomId, loopback);
@@ skipping 25 matching lines @@
     peerConnectionClient = PeerConnectionClient.getInstance();
     if (loopback) {
       PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();
       options.networkIgnoreMask = 0;
       peerConnectionClient.setPeerConnectionFactoryOptions(options);
     }
     peerConnectionClient.createPeerConnectionFactory(
         CallActivity.this, peerConnectionParameters, CallActivity.this);
   }
 
+  private boolean useCamera2() {
+    return Camera2Enumerator.isSupported(this) && getIntent().getBooleanExtra(EXTRA_CAMERA2, true);
+  }
+
+  private boolean captureToTexture() {
+    return getIntent().getBooleanExtra(EXTRA_CAPTURETOTEXTURE_ENABLED, false);
+  }
+
+  private VideoCapturer createCameraCapturer(CameraEnumerator enumerator) {
+    final String[] deviceNames = enumerator.getDeviceNames();
+
+    // First, try to find front facing camera
+    Logging.d(TAG, "Looking for front facing cameras.");
+    for (String deviceName : deviceNames) {
+      if (enumerator.isFrontFacing(deviceName)) {
+        Logging.d(TAG, "Creating front facing camera capturer.");
+        VideoCapturer videoCapturer = enumerator.createCapturer(deviceName, null);
+
+        if (videoCapturer != null) {
+          return videoCapturer;
+        }
+      }
+    }
+
+    // Front facing camera not found, try something else
+    Logging.d(TAG, "Looking for other cameras.");
+    for (String deviceName : deviceNames) {
+      if (!enumerator.isFrontFacing(deviceName)) {
+        Logging.d(TAG, "Creating other camera capturer.");
+        VideoCapturer videoCapturer = enumerator.createCapturer(deviceName, null);
+
+        if (videoCapturer != null) {
+          return videoCapturer;
+        }
+      }
+    }
+
+    return null;
+  }
+
   // Activity interfaces
   @Override
   public void onPause() {
     super.onPause();
     activityRunning = false;
     if (peerConnectionClient != null) {
       peerConnectionClient.stopVideoSource();
     }
     cpuMonitor.pause();
   }
@@ skipping 68 matching lines @@
     } else {
       ft.hide(callFragment);
       ft.hide(hudFragment);
     }
     ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
     ft.commit();
   }
 
   private void updateVideoView() {
     remoteRenderLayout.setPosition(REMOTE_X, REMOTE_Y, REMOTE_WIDTH, REMOTE_HEIGHT);
-    remoteRender.setScalingType(scalingType);
-    remoteRender.setMirror(false);
+    remoteRenderScreen.setScalingType(scalingType);
+    remoteRenderScreen.setMirror(false);
 
     if (iceConnected) {
       localRenderLayout.setPosition(
           LOCAL_X_CONNECTED, LOCAL_Y_CONNECTED, LOCAL_WIDTH_CONNECTED, LOCAL_HEIGHT_CONNECTED);
       localRender.setScalingType(ScalingType.SCALE_ASPECT_FIT);
     } else {
       localRenderLayout.setPosition(
           LOCAL_X_CONNECTING, LOCAL_Y_CONNECTING, LOCAL_WIDTH_CONNECTING, LOCAL_HEIGHT_CONNECTING);
       localRender.setScalingType(scalingType);
     }
     localRender.setMirror(true);
 
     localRender.requestLayout();
-    remoteRender.requestLayout();
+    remoteRenderScreen.requestLayout();
   }
 
   private void startCall() {
     if (appRtcClient == null) {
       Log.e(TAG, "AppRTC client is not allocated for a call.");
       return;
     }
     callStartedTimeMs = System.currentTimeMillis();
 
     // Start room connection.
@@ skipping 43 matching lines @@
       appRtcClient = null;
     }
     if (peerConnectionClient != null) {
       peerConnectionClient.close();
       peerConnectionClient = null;
     }
     if (localRender != null) {
       localRender.release();
       localRender = null;
     }
-    if (remoteRender != null) {
-      remoteRender.release();
-      remoteRender = null;
+    if (videoFileRenderer != null) {
+      videoFileRenderer.release();
+      videoFileRenderer = null;
+    }
+    if (remoteRenderScreen != null) {
+      remoteRenderScreen.release();
+      remoteRenderScreen = null;
     }
     if (audioManager != null) {
       audioManager.close();
       audioManager = null;
     }
     if (iceConnected && !isError) {
       setResult(RESULT_OK);
     } else {
       setResult(RESULT_CANCELED);
     }
@@ skipping 37 matching lines @@
       @Override
       public void run() {
         if (!isError) {
           isError = true;
           disconnectWithErrorMessage(description);
         }
       }
     });
   }
 
+  private VideoCapturer createVideoCapturer() {
+    VideoCapturer videoCapturer = null;
+    String videoFileAsCamera = getIntent().getStringExtra(EXTRA_VIDEO_FILE_AS_CAMERA);
+    if (videoFileAsCamera != null) {
+      try {
+        videoCapturer = new FileVideoCapturer(videoFileAsCamera);
+      } catch (IOException e) {
+        reportError("Failed to open video file for emulated camera");
+        return null;
+      }
+    } else if (useCamera2()) {
+      if (!captureToTexture()) {
+        reportError(getString(R.string.camera2_texture_only_error));
+        return null;
+      }
+
+      Logging.d(TAG, "Creating capturer using camera2 API.");
+      videoCapturer = createCameraCapturer(new Camera2Enumerator(this));
+    } else {
+      Logging.d(TAG, "Creating capturer using camera1 API.");
+      videoCapturer = createCameraCapturer(new Camera1Enumerator(captureToTexture()));
+    }
+    if (videoCapturer == null) {
+      reportError("Failed to open camera");
+      return null;
+    }
+    return videoCapturer;
+  }
+
   // -----Implementation of AppRTCClient.AppRTCSignalingEvents ---------------
   // All callbacks are invoked from websocket signaling looper thread and
   // are routed to UI thread.
   private void onConnectedToRoomInternal(final SignalingParameters params) {
     final long delta = System.currentTimeMillis() - callStartedTimeMs;
 
     signalingParameters = params;
     logAndToast("Creating peer connection, delay=" + delta + "ms");
-    peerConnectionClient.createPeerConnection(
-        rootEglBase.getEglBaseContext(), localRender, remoteRender, signalingParameters);
+    VideoCapturer videoCapturer = null;
+    if (peerConnectionParameters.videoCallEnabled) {
+      videoCapturer = createVideoCapturer();
+    }
+    peerConnectionClient.createPeerConnection(rootEglBase.getEglBaseContext(), localRender,
+        remoteRenderers, videoCapturer, signalingParameters);
 
     if (signalingParameters.initiator) {
       logAndToast("Creating OFFER...");
       // Create offer. Offer SDP will be sent to answering client in
       // PeerConnectionEvents.onLocalDescription event.
       peerConnectionClient.createOffer();
     } else {
       if (params.offerSdp != null) {
         peerConnectionClient.setRemoteDescription(params.offerSdp);
         logAndToast("Creating ANSWER...");
@@ skipping 174 matching lines @@
         }
       }
     });
   }
 
   @Override
   public void onPeerConnectionError(final String description) {
     reportError(description);
   }
 }