Enabling unbundling of audio/video

Author: taste1981

talk/owt/sdk/base/globalconfiguration.cc

@@ -29,5 +29,6 @@ int GlobalConfiguration::screen_min_ = 0;
 int GlobalConfiguration::screen_max_ = 0;
 int GlobalConfiguration::data_min_ = 0;
 int GlobalConfiguration::data_max_ = 0;
+bool GlobalConfiguration::pre_decode_dump_enabled_ = false;
 }  // namespace base
 }

talk/owt/sdk/base/peerconnectionchannel.cc

@@ -7,6 +7,8 @@
 #include "webrtc/api/peer_connection_interface.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/rtc_base/thread.h"
+#include "webrtc/system_wrappers/include/field_trial.h"
+
 using namespace rtc;
 namespace owt {
 namespace base {
@@ -32,7 +34,10 @@ bool PeerConnectionChannel::InitializePeerConnection() {
   configuration_.sdp_semantics = webrtc::SdpSemantics::kUnifiedPlan;
   configuration_.media_config.enable_dscp = true;
   // Johny: This must not be set if we use seperate AV channels.
-  //configuration_.bundle_policy = webrtc::PeerConnectionInterface::BundlePolicy::kBundlePolicyMaxBundle;
+  if (!webrtc::field_trial::IsEnabled("OWT-IceUnbundle")) {
+     configuration_.bundle_policy =
+       webrtc::PeerConnectionInterface::BundlePolicy::kBundlePolicyMaxBundle;
+  }
   peer_connection_ =
       (factory_->CreatePeerConnection(configuration_, this)).get();
   if (!peer_connection_.get()) {

talk/owt/sdk/base/peerconnectiondependencyfactory.cc

@@ -17,6 +17,7 @@
 #include "webrtc/modules/audio_device/include/audio_device_factory.h"
 #endif
 #include "webrtc/modules/audio_processing/include/audio_processing.h"
+#include "webrtc/p2p/client/basic_port_allocator.h"
 #include "webrtc/rtc_base/bind.h"
 #include "webrtc/rtc_base/ssl_adapter.h"
 #include "webrtc/rtc_base/thread.h"
@@ -108,16 +109,12 @@ void PeerConnectionDependencyFactory::
       video_max > video_min) || (screen_min > 0 && screen_max > screen_min) ||
       (data_min > 0 && data_max > data_min)) {
     field_trial_ += "OWT-IceUnbundle/Enabled/";
-    field_trial_ +=
-        "OWT-Ice-PortRanges/audioMin:" + std::to_string(audio_min) +
-        ",audioMax:" + std::to_string(audio_max) +
-        ",videoMin:" + std::to_string(video_min) +
-        ",videoMax:" + std::to_string(video_max) +
-        ",screenMin:" + std::to_string(screen_min) +
-        ",screenMax:" + std::to_string(screen_max) +
-        ",dataMin:" + std::to_string(data_min) +
-        ",dataMax:" + std::to_string(data_max) + "/";
   }
+  bool pre_decode_dump = GlobalConfiguration::GetPreDecodeDumpEnabled();
+  if (pre_decode_dump) {
+    field_trial_ += "WebRTC-DecoderDataDumpDirectory/./";
+  }
+
   // Set H.264 temporal layers. Ideally it should be set via RtpSenderParam
   int h264_temporal_layers = GlobalConfiguration::GetH264TemporalLayers();
   field_trial_ +=
@@ -141,6 +138,10 @@ void PeerConnectionDependencyFactory::
             network_thread->Start())
       << "Failed to start threads";
 
+  network_manager_ = std::make_shared<rtc::BasicNetworkManager>();
+  packet_socket_factory_ =
+      std::make_shared<rtc::BasicPacketSocketFactory>(network_thread.get());
+
   // Use webrtc::VideoEn(De)coderFactory on iOS.
   std::unique_ptr<webrtc::VideoEncoderFactory> encoder_factory;
   std::unique_ptr<webrtc::VideoDecoderFactory> decoder_factory;
@@ -216,7 +217,29 @@ scoped_refptr<webrtc::PeerConnectionInterface>
 PeerConnectionDependencyFactory::CreatePeerConnectionOnCurrentThread(
     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
     webrtc::PeerConnectionObserver* observer) {
-  return (pc_factory_->CreatePeerConnection(config, nullptr, nullptr, observer))
+  std::unique_ptr<cricket::PortAllocator> port_allocator;
+  port_allocator.reset(new cricket::BasicPortAllocator(
+      network_manager_.get(), packet_socket_factory_.get()));
+  // Handle port ranges.
+  int audio_min, audio_max, video_min, video_max, screen_min, screen_max,
+      data_min, data_max;
+  GlobalConfiguration::GetPortRanges(audio_min, audio_max, video_min, video_max,
+                                     screen_min, screen_max, data_min,
+                                     data_max);
+  if (audio_min > 0 && audio_max > audio_min) {
+    port_allocator->SetAudioPortRange(audio_min, audio_max);
+  }
+  if (video_min > 0 && video_max > video_min) {
+    port_allocator->SetVideoPortRange(video_min, video_max);
+  }
+  if (screen_min > 0 && screen_max > screen_min) {
+    port_allocator->SetScreenPortRange(screen_min, screen_max);
+  }
+  if (data_min > 0 && data_max > data_min) {
+    port_allocator->SetDataPortRange(data_min, data_max);
+  }
+  return (pc_factory_->CreatePeerConnection(config, std::move(port_allocator),
+                                            nullptr, observer))
       .get();
 }
 void PeerConnectionDependencyFactory::CreatePeerConnectionFactory() {

talk/owt/sdk/base/peerconnectiondependencyfactory.h

@@ -12,6 +12,8 @@
 #endif
 #include "webrtc/sdk/media_constraints.h"
 #include "webrtc/rtc_base/bind.h"
+#include "webrtc/rtc_base/network.h"
+#include "webrtc/p2p/base/basic_packet_socket_factory.h"
 namespace owt {
 namespace base {
 using webrtc::MediaStreamInterface;
@@ -94,6 +96,8 @@ class PeerConnectionDependencyFactory : public rtc::RefCountInterface {
   std::unique_ptr<webrtc::ScopedCOMInitializer> com_initializer_;
   std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
 #endif
+  std::shared_ptr<rtc::BasicNetworkManager> network_manager_;
+  std::shared_ptr<rtc::BasicPacketSocketFactory> packet_socket_factory_;
 };
 }
 }  // namespace owt

talk/owt/sdk/include/cpp/owt/base/globalconfiguration.h

@@ -103,6 +103,13 @@ class GlobalConfiguration {
     data_max_ = data_max;
   }
 
+  /**
+   @brief This function enables stream dump before decoder.
+  */
+  static void SetPreDecodeDumpEnabled(bool enabled) {
+    pre_decode_dump_enabled_ = enabled;
+  }
+
   /**
    @brief This function sets the temporal layers for H.264.
 
@@ -198,6 +205,7 @@ class GlobalConfiguration {
   static bool GetCustomizedAudioInputEnabled() {
     return audio_frame_generator_ ? true : false;
   }
+
   static void GetPortRanges(int& audio_min,
       int& audio_max,
       int& video_min,
@@ -217,6 +225,7 @@ class GlobalConfiguration {
     data_min = data_min_;
     data_max = data_max_;
   }
+
   static int audio_min_;
   static int audio_max_;
   static int video_min_;
@@ -225,6 +234,12 @@ class GlobalConfiguration {
   static int screen_max_;
   static int data_min_;
   static int data_max_;
+
+  static bool GetPreDecodeDumpEnabled() {
+    return pre_decode_dump_enabled_;
+  }
+
+  static bool pre_decode_dump_enabled_;
   /**
    @brief This function gets whether auto echo cancellation is enabled or not.
    @return true or false.

talk/owt/sdk/p2p/p2ppeerconnectionchannel.cc

@@ -10,7 +10,7 @@
 #include "talk/owt/sdk/p2p/p2ppeerconnectionchannel.h"
 #include "webrtc/rtc_base/logging.h"
 #include "webrtc/api/task_queue/default_task_queue_factory.h"
-
+#include "webrtc/system_wrappers/include/field_trial.h"
 using namespace rtc;
 namespace owt {
 namespace p2p {
@@ -284,8 +284,11 @@ void P2PPeerConnectionChannel::CreateOffer() {
           std::bind(
               &P2PPeerConnectionChannel::OnCreateSessionDescriptionFailure,
               this, std::placeholders::_1));
-  peer_connection_->CreateOffer(
-      observer, webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
+  bool rtp_no_mux = webrtc::field_trial::IsEnabled("OWT-IceUnbundle");
+  auto offer_answer_options =
+      webrtc::PeerConnectionInterface::RTCOfferAnswerOptions();
+  offer_answer_options.use_rtp_mux = !rtp_no_mux;
+  peer_connection_->CreateOffer(observer, offer_answer_options);
 }
 void P2PPeerConnectionChannel::CreateAnswer() {
   RTC_LOG(LS_INFO) << "Create answer.";
@@ -297,8 +300,11 @@ void P2PPeerConnectionChannel::CreateAnswer() {
           std::bind(
               &P2PPeerConnectionChannel::OnCreateSessionDescriptionFailure,
               this, std::placeholders::_1));
-  peer_connection_->CreateAnswer(
-      observer, webrtc::PeerConnectionInterface::RTCOfferAnswerOptions());
+  bool rtp_no_mux = webrtc::field_trial::IsEnabled("OWT-IceUnbundle");
+  auto offer_answer_options =
+      webrtc::PeerConnectionInterface::RTCOfferAnswerOptions();
+  offer_answer_options.use_rtp_mux = !rtp_no_mux;
+  peer_connection_->CreateAnswer(observer, offer_answer_options);
 }
 void P2PPeerConnectionChannel::SendSignalingMessage(
     const Json::Value& data,