Fix VP9 support in 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 37 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";
   private static final String TAG = "PCRTCClient";
-  private static final String FIELD_TRIAL_VP9 = "WebRTC-SupportVP9/Enabled/";
   private static final String FIELD_TRIAL_AUTOMATIC_RESIZE =
       "WebRTC-MediaCodecVideoEncoder-AutomaticResize/Enabled/";
   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";
@@ skipping 18 matching lines @@
   private final PCObserver pcObserver = new PCObserver();
   private final SDPObserver sdpObserver = new SDPObserver();
   private final LooperExecutor executor;
 
   private PeerConnectionFactory factory;
   private PeerConnection peerConnection;
   PeerConnectionFactory.Options options = null;
   private VideoSource videoSource;
   private boolean videoCallEnabled;
   private boolean preferIsac;
-  private boolean preferH264;
+  private String preferredVideoCodec;
   private boolean videoSourceStopped;
   private boolean isError;
   private Timer statsTimer;
   private VideoRenderer.Callbacks localRender;
   private VideoRenderer.Callbacks remoteRender;
   private SignalingParameters signalingParameters;
   private MediaConstraints pcConstraints;
   private MediaConstraints videoConstraints;
   private MediaConstraints audioConstraints;
   private MediaConstraints sdpMediaConstraints;
@@ skipping 113 matching lines @@
       final Context context,
       final PeerConnectionParameters peerConnectionParameters,
       final PeerConnectionEvents events) {
     this.peerConnectionParameters = peerConnectionParameters;
     this.events = events;
     videoCallEnabled = peerConnectionParameters.videoCallEnabled;
     // Reset variables to initial states.
     factory = null;
     peerConnection = null;
     preferIsac = false;
-    preferH264 = false;
     videoSourceStopped = false;
     isError = false;
     queuedRemoteCandidates = null;
     localSdp = null; // either offer or answer SDP
     mediaStream = null;
     videoCapturer = null;
     renderVideo = true;
     localVideoTrack = null;
     remoteVideoTrack = null;
     statsTimer = new Timer();
@@ skipping 39 matching lines @@
   public boolean isVideoCallEnabled() {
     return videoCallEnabled;
   }
 
   private void createPeerConnectionFactoryInternal(Context context) {
     Log.d(TAG, "Create peer connection factory. Use video: " +
         peerConnectionParameters.videoCallEnabled);
     isError = false;
 
     // Initialize field trials.
-    String field_trials = FIELD_TRIAL_AUTOMATIC_RESIZE;
-    // Check if VP9 is used by default.
-    if (videoCallEnabled && peerConnectionParameters.videoCodec != null
-        && peerConnectionParameters.videoCodec.equals(VIDEO_CODEC_VP9)) {
-      field_trials += FIELD_TRIAL_VP9;
+    PeerConnectionFactory.initializeFieldTrials(FIELD_TRIAL_AUTOMATIC_RESIZE);
+
+    // Check preferred video codec.
+    preferredVideoCodec = VIDEO_CODEC_VP8;
+    if (videoCallEnabled && peerConnectionParameters.videoCodec != null) {
+      if (peerConnectionParameters.videoCodec.equals(VIDEO_CODEC_VP9)) {
+        preferredVideoCodec = VIDEO_CODEC_VP9;
+      } else if (peerConnectionParameters.videoCodec.equals(VIDEO_CODEC_H264)) {
+        preferredVideoCodec = VIDEO_CODEC_H264;
+      }
     }
-    PeerConnectionFactory.initializeFieldTrials(field_trials);
+    Log.d(TAG, "Pereferred video codec: " + preferredVideoCodec);
 
-    // Check if H.264 is used by default.
-    preferH264 = false;
-    if (videoCallEnabled && peerConnectionParameters.videoCodec != null
-        && peerConnectionParameters.videoCodec.equals(VIDEO_CODEC_H264)) {
-      preferH264 = true;
-    }
     // Check if ISAC is used by default.
     preferIsac = false;
     if (peerConnectionParameters.audioCodec != null
         && peerConnectionParameters.audioCodec.equals(AUDIO_CODEC_ISAC)) {
       preferIsac = true;
     }
     if (!PeerConnectionFactory.initializeAndroidGlobals(context, true, true,
         peerConnectionParameters.videoCodecHwAcceleration)) {
       events.onPeerConnectionError("Failed to initializeAndroidGlobals");
     }
@@ skipping 301 matching lines @@
     executor.execute(new Runnable() {
       @Override
       public void run() {
         if (peerConnection == null || isError) {
           return;
         }
         String sdpDescription = sdp.description;
         if (preferIsac) {
           sdpDescription = preferCodec(sdpDescription, AUDIO_CODEC_ISAC, true);
         }
-        if (videoCallEnabled && preferH264) {
-          sdpDescription = preferCodec(sdpDescription, VIDEO_CODEC_H264, false);
+        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) {
@@ skipping 327 matching lines @@
     @Override
     public void onCreateSuccess(final SessionDescription origSdp) {
       if (localSdp != null) {
         reportError("Multiple SDP create.");
         return;
       }
       String sdpDescription = origSdp.description;
       if (preferIsac) {
         sdpDescription = preferCodec(sdpDescription, AUDIO_CODEC_ISAC, true);
       }
-      if (videoCallEnabled && preferH264) {
-        sdpDescription = preferCodec(sdpDescription, VIDEO_CODEC_H264, false);
+      if (videoCallEnabled) {
+        sdpDescription = preferCodec(sdpDescription, preferredVideoCodec, false);
       }
       final SessionDescription sdp = new SessionDescription(
           origSdp.type, sdpDescription);
       localSdp = sdp;
       executor.execute(new Runnable() {
         @Override
         public void run() {
           if (peerConnection != null && !isError) {
             Log.d(TAG, "Set local SDP from " + sdp.type);
             peerConnection.setLocalDescription(sdpObserver, sdp);
@@ skipping 46 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }