Add option to set maximum video encoder bitrate to AppRTCDemo.

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 11 matching lines @@
 import org.webrtc.Camera1Enumerator;
 import org.webrtc.Camera2Enumerator;
 import org.webrtc.CameraEnumerationAndroid;
 import org.webrtc.CameraEnumerator;
 import org.webrtc.CameraVideoCapturer;
 import org.webrtc.DataChannel;
 import org.webrtc.EglBase;
 import org.webrtc.IceCandidate;
 import org.webrtc.Logging;
 import org.webrtc.MediaConstraints;
-import org.webrtc.MediaConstraints.KeyValuePair;
 import org.webrtc.MediaStream;
 import org.webrtc.PeerConnection;
 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.VideoSource;
 import org.webrtc.VideoTrack;
 import org.webrtc.voiceengine.WebRtcAudioManager;
 import org.webrtc.voiceengine.WebRtcAudioUtils;
@@ skipping 12 matching lines @@
 /**
  * Peer connection client implementation.
  *
  * <p>All public methods are routed to local looper thread.
  * All PeerConnectionEvents callbacks are invoked from the same looper thread.
  * This class is a singleton.
  */
 public class PeerConnectionClient {
   public static final String VIDEO_TRACK_ID = "ARDAMSv0";
   public static final String AUDIO_TRACK_ID = "ARDAMSa0";
+  public static final String VIDEO_TRACK_TYPE = "video";
   private static final String TAG = "PCRTCClient";
   private static final String VIDEO_CODEC_VP8 = "VP8";
   private static final String VIDEO_CODEC_VP9 = "VP9";
   private static final String VIDEO_CODEC_H264 = "H264";
   private static final String AUDIO_CODEC_OPUS = "opus";
   private static final String AUDIO_CODEC_ISAC = "ISAC";
   private static final String VIDEO_CODEC_PARAM_START_BITRATE =
       "x-google-start-bitrate";
   private static final String AUDIO_CODEC_PARAM_BITRATE = "maxaveragebitrate";
   private static final String AUDIO_ECHO_CANCELLATION_CONSTRAINT = "googEchoCancellation";
   private static final String AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT= "googAutoGainControl";
   private static final String AUDIO_HIGH_PASS_FILTER_CONSTRAINT  = "googHighpassFilter";
   private static final String AUDIO_NOISE_SUPPRESSION_CONSTRAINT = "googNoiseSuppression";
   private static final String AUDIO_LEVEL_CONTROL_CONSTRAINT = "levelControl";
-  private static final String MAX_VIDEO_WIDTH_CONSTRAINT = "maxWidth";
-  private static final String MIN_VIDEO_WIDTH_CONSTRAINT = "minWidth";
-  private static final String MAX_VIDEO_HEIGHT_CONSTRAINT = "maxHeight";
-  private static final String MIN_VIDEO_HEIGHT_CONSTRAINT = "minHeight";
-  private static final String MAX_VIDEO_FPS_CONSTRAINT = "maxFrameRate";
-  private static final String MIN_VIDEO_FPS_CONSTRAINT = "minFrameRate";
   private static final String DTLS_SRTP_KEY_AGREEMENT_CONSTRAINT = "DtlsSrtpKeyAgreement";
   private static final int HD_VIDEO_WIDTH = 1280;
   private static final int HD_VIDEO_HEIGHT = 720;
   private static final int MAX_VIDEO_WIDTH = 1280;
   private static final int MAX_VIDEO_HEIGHT = 1280;
   private static final int MAX_VIDEO_FPS = 30;
+  private static final int BPS_IN_KBPS = 1000;
 
   private static final PeerConnectionClient instance = new PeerConnectionClient();
   private final PCObserver pcObserver = new PCObserver();
   private final SDPObserver sdpObserver = new SDPObserver();
   private final ScheduledExecutorService executor;
 
   private Context context;
   private PeerConnectionFactory factory;
   private PeerConnection peerConnection;
   PeerConnectionFactory.Options options = null;
@@ skipping 23 matching lines @@
   private PeerConnectionEvents events;
   private boolean isInitiator;
   private SessionDescription localSdp; // either offer or answer SDP
   private MediaStream mediaStream;
   private int numberOfCameras;
   private CameraVideoCapturer videoCapturer;
   // enableVideo is set to true if video should be rendered and sent.
   private boolean renderVideo;
   private VideoTrack localVideoTrack;
   private VideoTrack remoteVideoTrack;
+  private RtpSender localVideoSender;
   // enableAudio is set to true if audio should be sent.
   private boolean enableAudio;
   private AudioTrack localAudioTrack;
 
   /**
    * Peer connection parameters.
    */
   public static class PeerConnectionParameters {
     public final boolean videoCallEnabled;
     public final boolean loopback;
     public final boolean tracing;
     public final boolean useCamera2;
     public final int videoWidth;
     public final int videoHeight;
     public final int videoFps;
-    public final int videoStartBitrate;
+    public final int videoMaxBitrate;
     public final String videoCodec;
     public final boolean videoCodecHwAcceleration;
     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 PeerConnectionParameters(
         boolean videoCallEnabled, boolean loopback, boolean tracing, boolean useCamera2,
         int videoWidth, int videoHeight, int videoFps,
-        int videoStartBitrate, String videoCodec, boolean videoCodecHwAcceleration,
+        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) {
       this.videoCallEnabled = videoCallEnabled;
       this.useCamera2 = useCamera2;
       this.loopback = loopback;
       this.tracing = tracing;
       this.videoWidth = videoWidth;
       this.videoHeight = videoHeight;
       this.videoFps = videoFps;
-      this.videoStartBitrate = videoStartBitrate;
+      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;
@@ skipping 78 matching lines @@
     preferIsac = false;
     videoCapturerStopped = false;
     isError = false;
     queuedRemoteCandidates = null;
     localSdp = null; // either offer or answer SDP
     mediaStream = null;
     videoCapturer = null;
     renderVideo = true;
     localVideoTrack = null;
     remoteVideoTrack = null;
+    localVideoSender = null;
     enableAudio = true;
     localAudioTrack = null;
     statsTimer = new Timer();
 
     executor.execute(new Runnable() {
       @Override
       public void run() {
         createPeerConnectionFactoryInternal(context);
       }
     });
@@ skipping 269 matching lines @@
 
       if (videoCapturer == null) {
         reportError("Failed to open camera");
         return;
       }
       mediaStream.addTrack(createVideoTrack(videoCapturer));
     }
 
     mediaStream.addTrack(createAudioTrack());
     peerConnection.addStream(mediaStream);
+    if (videoCallEnabled) {
+      findVideoSender();
+    }
 
     if (peerConnectionParameters.aecDump) {
       try {
         aecDumpFileDescriptor = ParcelFileDescriptor.open(
             new File(Environment.getExternalStorageDirectory().getPath()
                 + File.separator
                 + "Download/audio.aecdump"),
                 ParcelFileDescriptor.MODE_READ_WRITE |
                 ParcelFileDescriptor.MODE_CREATE |
                 ParcelFileDescriptor.MODE_TRUNCATE);
@@ skipping 183 matching lines @@
         if (peerConnection == null || isError) {
           return;
         }
         String sdpDescription = sdp.description;
         if (preferIsac) {
           sdpDescription = preferCodec(sdpDescription, AUDIO_CODEC_ISAC, true);
         }
         if (videoCallEnabled) {
           sdpDescription = preferCodec(sdpDescription, preferredVideoCodec, false);
         }
-        if (videoCallEnabled && peerConnectionParameters.videoStartBitrate > 0) {
-          sdpDescription = setStartBitrate(VIDEO_CODEC_VP8, true,
-              sdpDescription, peerConnectionParameters.videoStartBitrate);
-          sdpDescription = setStartBitrate(VIDEO_CODEC_VP9, true,
-              sdpDescription, peerConnectionParameters.videoStartBitrate);
-          sdpDescription = setStartBitrate(VIDEO_CODEC_H264, true,
-              sdpDescription, peerConnectionParameters.videoStartBitrate);
-        }
         if (peerConnectionParameters.audioStartBitrate > 0) {
           sdpDescription = setStartBitrate(AUDIO_CODEC_OPUS, false,
               sdpDescription, peerConnectionParameters.audioStartBitrate);
         }
         Log.d(TAG, "Set remote SDP.");
         SessionDescription sdpRemote = new SessionDescription(
             sdp.type, sdpDescription);
         peerConnection.setRemoteDescription(sdpObserver, sdpRemote);
       }
     });
@@ skipping 20 matching lines @@
       public void run() {
         if (videoCapturer != null && videoCapturerStopped) {
           Log.d(TAG, "Restart video source.");
           videoCapturer.startCapture(videoWidth, videoHeight, videoFps);
           videoCapturerStopped = false;
         }
       }
     });
   }
 
+  public void setVideoMaxBitrate(final Integer maxBitrateKbps) {
+    executor.execute(new Runnable() {
+      @Override
+      public void run() {
+        if (peerConnection == null || localVideoSender == null || isError) {
+          return;
+        }
+        Log.d(TAG, "Requested max video bitrate: " + maxBitrateKbps);
+        if (localVideoSender == null) {
+          Log.w(TAG, "Sender is not ready.");
+          return;
+        }
+
+        RtpParameters parameters = localVideoSender.getParameters();
+        if (parameters.encodings.size() == 0) {
+          Log.w(TAG, "RtpParameters are not ready.");
+          return;
+        }
+
+        for (RtpParameters.Encoding encoding : parameters.encodings) {
+          // Null value means no limit.
+          encoding.maxBitrateBps = maxBitrateKbps == null
+              ? null
+              : maxBitrateKbps * BPS_IN_KBPS;
+        }
+        if (!localVideoSender.setParameters(parameters)) {
+          Log.e(TAG, "RtpSender.setParameters failed.");
+        }
+        Log.d(TAG, "Configured max video bitrate to: " + maxBitrateKbps);
+      }
+    });
+  }
+
   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;
         }
       }
@@ skipping 10 matching lines @@
   private VideoTrack createVideoTrack(VideoCapturer capturer) {
     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 void findVideoSender() {
+    for (RtpSender sender : peerConnection.getSenders()) {
+      if (sender.track() != null) {
+        String trackType = sender.track().kind();
+        if (trackType.equals(VIDEO_TRACK_TYPE)) {
+          Log.d(TAG, "Found video sender.");
+          localVideoSender = sender;
+        }

[wzh, 2016/09/01 06:38:43]

do you need an early return or a break here?

+      }
+    }
+  }
+
   private static String setStartBitrate(String codec, boolean isVideoCodec,
       String sdpDescription, int bitrateKbps) {
     String[] lines = sdpDescription.split("\r\n");
     int rtpmapLineIndex = -1;
     boolean sdpFormatUpdated = false;
     String codecRtpMap = null;
     // Search for codec rtpmap in format
     // a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>]
     String regex = "^a=rtpmap:(\\d+) " + codec + "(/\\d+)+[\r]?$";
     Pattern codecPattern = Pattern.compile(regex);
@@ skipping 336 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }