AndroidVideoTrackSource implementation

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 89 matching lines @@
 
   private Context context;
   private PeerConnectionFactory factory;
   private PeerConnection peerConnection;
   PeerConnectionFactory.Options options = null;
   private AudioSource audioSource;
   private VideoSource videoSource;
   private boolean videoCallEnabled;
   private boolean preferIsac;
   private String preferredVideoCodec;
-  private boolean videoSourceStopped;
+  private boolean videoCapturerStopped;
   private boolean isError;
   private Timer statsTimer;
   private VideoRenderer.Callbacks localRender;
   private VideoRenderer.Callbacks remoteRender;
   private SignalingParameters signalingParameters;
   private MediaConstraints pcConstraints;
-  private MediaConstraints videoConstraints;
+  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
   // remote descriptions are set. Similarly local ICE candidates are sent to
   // remote peer after both local and remote description are set.
   private LinkedList<IceCandidate> queuedRemoteCandidates;
   private PeerConnectionEvents events;
   private boolean isInitiator;
@@ skipping 125 matching lines @@
       final PeerConnectionParameters peerConnectionParameters,
       final PeerConnectionEvents events) {
     this.peerConnectionParameters = peerConnectionParameters;
     this.events = events;
     videoCallEnabled = peerConnectionParameters.videoCallEnabled;
     // Reset variables to initial states.
     this.context = null;
     factory = null;
     peerConnection = null;
     preferIsac = false;
-    videoSourceStopped = false;
+    videoCapturerStopped = false;
     isError = false;
     queuedRemoteCandidates = null;
     localSdp = null; // either offer or answer SDP
     mediaStream = null;
     videoCapturer = null;
     renderVideo = true;
     localVideoTrack = null;
     remoteVideoTrack = null;
     enableAudio = true;
     localAudioTrack = null;
@@ skipping 118 matching lines @@
     }
 
     // Check if there is a camera on device and disable video call if not.
     numberOfCameras = CameraEnumerationAndroid.getDeviceCount();
     if (numberOfCameras == 0) {
       Log.w(TAG, "No camera on device. Switch to audio only call.");
       videoCallEnabled = false;
     }
     // Create video constraints if video call is enabled.
     if (videoCallEnabled) {
-      videoConstraints = new MediaConstraints();
-      int videoWidth = peerConnectionParameters.videoWidth;
-      int videoHeight = peerConnectionParameters.videoHeight;
+      videoWidth = peerConnectionParameters.videoWidth;
+      videoHeight = peerConnectionParameters.videoHeight;
+      videoFps = peerConnectionParameters.videoFps;
 
-      // If VP8 HW video encoder is supported and video resolution is not
-      // specified force it to HD.
-      if ((videoWidth == 0 || videoHeight == 0)
-          && peerConnectionParameters.videoCodecHwAcceleration
-          && MediaCodecVideoEncoder.isVp8HwSupported()) {
+      // If video resolution is not specified, default to HD.
+      if (videoWidth == 0 || videoHeight == 0) {
         videoWidth = HD_VIDEO_WIDTH;
         videoHeight = HD_VIDEO_HEIGHT;
       }
 
-      // Add video resolution constraints.
-      if (videoWidth > 0 && videoHeight > 0) {
-        videoWidth = Math.min(videoWidth, MAX_VIDEO_WIDTH);
-        videoHeight = Math.min(videoHeight, MAX_VIDEO_HEIGHT);
-        videoConstraints.mandatory.add(new KeyValuePair(
-            MIN_VIDEO_WIDTH_CONSTRAINT, Integer.toString(videoWidth)));
-        videoConstraints.mandatory.add(new KeyValuePair(
-            MAX_VIDEO_WIDTH_CONSTRAINT, Integer.toString(videoWidth)));
-        videoConstraints.mandatory.add(new KeyValuePair(
-            MIN_VIDEO_HEIGHT_CONSTRAINT, Integer.toString(videoHeight)));
-        videoConstraints.mandatory.add(new KeyValuePair(
-            MAX_VIDEO_HEIGHT_CONSTRAINT, Integer.toString(videoHeight)));
+      // If fps is not specified, default to 30.
+      if (videoFps == 0) {
+        videoFps = 30;
       }
 
-      // Add fps constraints.
-      int videoFps = peerConnectionParameters.videoFps;
-      if (videoFps > 0) {
-        videoFps = Math.min(videoFps, MAX_VIDEO_FPS);
-        videoConstraints.mandatory.add(new KeyValuePair(
-            MIN_VIDEO_FPS_CONSTRAINT, Integer.toString(videoFps)));
-        videoConstraints.mandatory.add(new KeyValuePair(
-            MAX_VIDEO_FPS_CONSTRAINT, Integer.toString(videoFps)));
-      }
+      videoWidth = Math.min(videoWidth, MAX_VIDEO_WIDTH);
+      videoHeight = Math.min(videoHeight, MAX_VIDEO_HEIGHT);
+      videoFps = Math.min(videoFps, MAX_VIDEO_FPS);
     }
 
     // Create audio constraints.
     audioConstraints = new MediaConstraints();
     // added for audio performance measurements
     if (peerConnectionParameters.noAudioProcessing) {
       Log.d(TAG, "Disabling audio processing");
       audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
             AUDIO_ECHO_CANCELLATION_CONSTRAINT, "false"));
       audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
@@ skipping 47 matching lines @@
   }
 
   private void createPeerConnectionInternal(EglBase.Context renderEGLContext) {
     if (factory == null || isError) {
       Log.e(TAG, "Peerconnection factory is not created");
       return;
     }
     Log.d(TAG, "Create peer connection.");
 
     Log.d(TAG, "PCConstraints: " + pcConstraints.toString());
-    if (videoConstraints != null) {
-      Log.d(TAG, "VideoConstraints: " + videoConstraints.toString());
-    }
     queuedRemoteCandidates = new LinkedList<IceCandidate>();
 
     if (videoCallEnabled) {
       Log.d(TAG, "EGLContext: " + renderEGLContext);
       factory.setVideoHwAccelerationOptions(renderEGLContext, renderEGLContext);
     }
 
     PeerConnection.RTCConfiguration rtcConfig =
         new PeerConnection.RTCConfiguration(signalingParameters.iceServers);
     // TCP candidates are only useful when connecting to a server that supports
@@ skipping 67 matching lines @@
     statsTimer.cancel();
     if (peerConnection != null) {
       peerConnection.dispose();
       peerConnection = null;
     }
     Log.d(TAG, "Closing audio source.");
     if (audioSource != null) {
       audioSource.dispose();
       audioSource = null;
     }
+    Log.d(TAG, "Stopping capture.");
+    if (videoCapturer != null) {
+      try {
+        videoCapturer.stopCapture();
+      } catch(InterruptedException e) {
+        throw new RuntimeException(e);
+      }
+      videoCapturer.dispose();
+      videoCapturer = null;
+    }
     Log.d(TAG, "Closing video source.");
     if (videoSource != null) {
       videoSource.dispose();
       videoSource = null;
     }
     Log.d(TAG, "Closing peer connection factory.");
     if (factory != null) {
       factory.dispose();
       factory = null;
     }
     options = null;
     Log.d(TAG, "Closing peer connection done.");
     events.onPeerConnectionClosed();
     PeerConnectionFactory.stopInternalTracingCapture();
     PeerConnectionFactory.shutdownInternalTracer();
   }
 
   public boolean isHDVideo() {
     if (!videoCallEnabled) {
       return false;
     }
-    int minWidth = 0;
-    int minHeight = 0;
-    for (KeyValuePair keyValuePair : videoConstraints.mandatory) {
-      if (keyValuePair.getKey().equals("minWidth")) {
-        try {
-          minWidth = Integer.parseInt(keyValuePair.getValue());
-        } catch (NumberFormatException e) {
-          Log.e(TAG, "Can not parse video width from video constraints");
-        }
-      } else if (keyValuePair.getKey().equals("minHeight")) {
-        try {
-          minHeight = Integer.parseInt(keyValuePair.getValue());
-        } catch (NumberFormatException e) {
-          Log.e(TAG, "Can not parse video height from video constraints");
-        }
-      }
-    }
-    return minWidth * minHeight >= 1280 * 720;
+
+    return videoWidth * videoHeight >= 1280 * 720;
   }
 
   private void getStats() {
     if (peerConnection == null || isError) {
       return;
     }
     boolean success = peerConnection.getStats(new StatsObserver() {
       @Override
       public void onComplete(final StatsReport[] reports) {
         events.onPeerConnectionStatsReady(reports);
@@ skipping 140 matching lines @@
             sdp.type, sdpDescription);
         peerConnection.setRemoteDescription(sdpObserver, sdpRemote);
       }
     });
   }
 
   public void stopVideoSource() {
     executor.execute(new Runnable() {
       @Override
       public void run() {
-        if (videoSource != null && !videoSourceStopped) {
+        if (videoCapturer != null && !videoCapturerStopped) {
           Log.d(TAG, "Stop video source.");
-          videoSource.stop();
-          videoSourceStopped = true;
+          try {
+            videoCapturer.stopCapture();
+          } catch (InterruptedException e) {}
+          videoCapturerStopped = true;
         }
       }
     });
   }
 
   public void startVideoSource() {
     executor.execute(new Runnable() {
       @Override
       public void run() {
-        if (videoSource != null && videoSourceStopped) {
+        if (videoCapturer != null && videoCapturerStopped) {
           Log.d(TAG, "Restart video source.");
-          videoSource.restart();
-          videoSourceStopped = false;
+          videoCapturer.startCapture(videoWidth, videoHeight, videoFps);
+          videoCapturerStopped = false;
         }
       }
     });
   }
 
   private void reportError(final String errorMessage) {
     Log.e(TAG, "Peerconnection error: " + errorMessage);
     executor.execute(new Runnable() {
       @Override
       public void run() {
         if (!isError) {
           events.onPeerConnectionError(errorMessage);
           isError = true;
         }
       }
     });
   }
 
   private AudioTrack createAudioTrack() {
     audioSource = factory.createAudioSource(audioConstraints);
     localAudioTrack = factory.createAudioTrack(AUDIO_TRACK_ID, audioSource);
     localAudioTrack.setEnabled(enableAudio);
     return localAudioTrack;
   }
 
   private VideoTrack createVideoTrack(VideoCapturer capturer) {
-    videoSource = factory.createVideoSource(capturer, videoConstraints);
+    videoSource = factory.createVideoSource(capturer);
+    capturer.startCapture(videoWidth, videoHeight, videoFps);
 
     localVideoTrack = factory.createVideoTrack(VIDEO_TRACK_ID, videoSource);
     localVideoTrack.setEnabled(renderVideo);
     localVideoTrack.addRenderer(new VideoRenderer(localRender));
     return localVideoTrack;
   }
 
   private static String setStartBitrate(String codec, boolean isVideoCodec,
       String sdpDescription, int bitrateKbps) {
     String[] lines = sdpDescription.split("\r\n");
@@ skipping 343 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }