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

webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.java

 /*
  *  Copyright 2014 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 23 matching lines @@
 import org.webrtc.PeerConnection.IceConnectionState;
 import org.webrtc.PeerConnectionFactory;
 import org.webrtc.RtpParameters;
 import org.webrtc.RtpSender;
 import org.webrtc.SdpObserver;
 import org.webrtc.SessionDescription;
 import org.webrtc.StatsObserver;
 import org.webrtc.StatsReport;
 import org.webrtc.VideoCapturer;
 import org.webrtc.VideoRenderer;
+import org.webrtc.VideoCapturerAndroid;
+import org.webrtc.CameraVideoCapturer;
+import org.webrtc.FileVideoCapturer;
+import org.webrtc.FileVideoCapturerTimer;
 import org.webrtc.VideoSource;
 import org.webrtc.VideoTrack;
 import org.webrtc.voiceengine.WebRtcAudioManager;
 import org.webrtc.voiceengine.WebRtcAudioUtils;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Collections;
 import java.util.EnumSet;
 import java.util.LinkedList;
+import java.util.List;
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
  * Peer connection client implementation.
  *
@@ skipping 38 matching lines @@
   PeerConnectionFactory.Options options = null;
   private AudioSource audioSource;
   private VideoSource videoSource;
   private boolean videoCallEnabled;
   private boolean preferIsac;
   private String preferredVideoCodec;
   private boolean videoCapturerStopped;
   private boolean isError;
   private Timer statsTimer;
   private VideoRenderer.Callbacks localRender;
-  private VideoRenderer.Callbacks remoteRender;
+  private List<VideoRenderer.Callbacks> remoteRenders;
   private SignalingParameters signalingParameters;
   private MediaConstraints pcConstraints;
   private int videoWidth;
   private int videoHeight;
   private int videoFps;
   private MediaConstraints audioConstraints;
   private ParcelFileDescriptor aecDumpFileDescriptor;
   private MediaConstraints sdpMediaConstraints;
   private PeerConnectionParameters peerConnectionParameters;
   // Queued remote ICE candidates are consumed only after both local and
@@ skipping 32 matching lines @@
     public final boolean captureToTexture;
     public final int audioStartBitrate;
     public final String audioCodec;
     public final boolean noAudioProcessing;
     public final boolean aecDump;
     public final boolean useOpenSLES;
     public final boolean disableBuiltInAEC;
     public final boolean disableBuiltInAGC;
     public final boolean disableBuiltInNS;
     public final boolean enableLevelControl;
+    public final String videoFileAsCamera;
+    public final int videoFileAsCameraWidth;
+    public final int videoFileAsCameraHeight;
 
     public PeerConnectionParameters(
         boolean videoCallEnabled, boolean loopback, boolean tracing, boolean useCamera2,
         int videoWidth, int videoHeight, int videoFps,
         int videoMaxBitrate, String videoCodec, boolean videoCodecHwAcceleration,
         boolean captureToTexture, int audioStartBitrate, String audioCodec,
         boolean noAudioProcessing, boolean aecDump, boolean useOpenSLES,
         boolean disableBuiltInAEC, boolean disableBuiltInAGC, boolean disableBuiltInNS,
-        boolean enableLevelControl) {
+        boolean enableLevelControl,
+        String videoFileAsCamera, int videoFileAsCameraWidth, int videoFileAsCameraHeight) {
+
       this.videoCallEnabled = videoCallEnabled;
       this.useCamera2 = useCamera2;
       this.loopback = loopback;
       this.tracing = tracing;
       this.videoWidth = videoWidth;
       this.videoHeight = videoHeight;
       this.videoFps = videoFps;
       this.videoMaxBitrate = videoMaxBitrate;
       this.videoCodec = videoCodec;
       this.videoCodecHwAcceleration = videoCodecHwAcceleration;
       this.captureToTexture = captureToTexture;
       this.audioStartBitrate = audioStartBitrate;
       this.audioCodec = audioCodec;
       this.noAudioProcessing = noAudioProcessing;
       this.aecDump = aecDump;
       this.useOpenSLES = useOpenSLES;
       this.disableBuiltInAEC = disableBuiltInAEC;
       this.disableBuiltInAGC = disableBuiltInAGC;
       this.disableBuiltInNS = disableBuiltInNS;
       this.enableLevelControl = enableLevelControl;
+      this.videoFileAsCamera = videoFileAsCamera;
+      this.videoFileAsCameraWidth = videoFileAsCameraWidth;
+      this.videoFileAsCameraHeight = videoFileAsCameraHeight;
     }
   }
 
   /**
    * Peer connection events.
    */
   public interface PeerConnectionEvents {
     /**
      * Callback fired once local SDP is created and set.
      */
@@ skipping 84 matching lines @@
         createPeerConnectionFactoryInternal(context);
       }
     });
   }
 
   public void createPeerConnection(
       final EglBase.Context renderEGLContext,
       final VideoRenderer.Callbacks localRender,
       final VideoRenderer.Callbacks remoteRender,
       final SignalingParameters signalingParameters) {
+    createPeerConnection(
+        renderEGLContext,
+        localRender,
+        Collections.singletonList(remoteRender),
+        signalingParameters);
+  }
+  public void createPeerConnection(
+      final EglBase.Context renderEGLContext,
+      final VideoRenderer.Callbacks localRender,
+      final List<VideoRenderer.Callbacks> remoteRenders,
+      final SignalingParameters signalingParameters) {
     if (peerConnectionParameters == null) {
       Log.e(TAG, "Creating peer connection without initializing factory.");
       return;
     }
     this.localRender = localRender;
-    this.remoteRender = remoteRender;
+    this.remoteRenders = remoteRenders;
     this.signalingParameters = signalingParameters;
     executor.execute(new Runnable() {
       @Override
       public void run() {
         try {
           createMediaConstraintsInternal();
           createPeerConnectionInternal(renderEGLContext);
         } catch (Exception e) {
           reportError("Failed to create peer connection: " + e.getMessage());
           throw e;
@@ skipping 224 matching lines @@
 
     // Set default WebRTC tracing and INFO libjingle logging.
     // NOTE: this _must_ happen while |factory| is alive!
     Logging.enableTracing(
         "logcat:",
         EnumSet.of(Logging.TraceLevel.TRACE_DEFAULT));
     Logging.enableLogToDebugOutput(Logging.Severity.LS_INFO);
 
     mediaStream = factory.createLocalMediaStream("ARDAMS");
     if (videoCallEnabled) {
-      if (peerConnectionParameters.useCamera2) {
+      if (peerConnectionParameters.videoFileAsCamera != null) {
+        FileVideoCapturer fileVideoCapturer = FileVideoCapturer.create(
+            peerConnectionParameters.videoFileAsCamera,
+            peerConnectionParameters.videoFileAsCameraWidth,
+            peerConnectionParameters.videoFileAsCameraHeight);
+
+        if (fileVideoCapturer == null) {
+          reportError("Failed to open video file for emulated camera");
+          return;
+        }
+        videoCapturer = new FileVideoCapturerTimer(fileVideoCapturer);
+      }
+      else if (peerConnectionParameters.useCamera2) {
         if (!peerConnectionParameters.captureToTexture) {
           reportError(context.getString(R.string.camera2_texture_only_error));
           return;
         }
 
         Logging.d(TAG, "Creating capturer using camera2 API.");
         createCapturer(new Camera2Enumerator(context));
       } else {
         Logging.d(TAG, "Creating capturer using camera1 API.");
         createCapturer(new Camera1Enumerator(peerConnectionParameters.captureToTexture));
       }
-
       if (videoCapturer == null) {
         reportError("Failed to open camera");
         return;
       }
       mediaStream.addTrack(createVideoTrack(videoCapturer));
     }
 
     mediaStream.addTrack(createAudioTrack());
     peerConnection.addStream(mediaStream);
     if (videoCallEnabled) {
@@ skipping 556 matching lines @@
           if (peerConnection == null || isError) {
             return;
           }
           if (stream.audioTracks.size() > 1 || stream.videoTracks.size() > 1) {
             reportError("Weird-looking stream: " + stream);
             return;
           }
           if (stream.videoTracks.size() == 1) {
             remoteVideoTrack = stream.videoTracks.get(0);
             remoteVideoTrack.setEnabled(renderVideo);
-            remoteVideoTrack.addRenderer(new VideoRenderer(remoteRender));
+            for (VideoRenderer.Callbacks remoteRender : remoteRenders) {
+              remoteVideoTrack.addRenderer(new VideoRenderer(remoteRender));
+            }
           }
         }
       });
     }
 
     @Override
     public void onRemoveStream(final MediaStream stream){
       executor.execute(new Runnable() {
         @Override
         public void run() {
@@ skipping 89 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }