Merge pull request #1026 from starwarfan/mst-88

Upgrade sdk to m88 for webrtc node

Author: starwarfan

scripts/installCommonDeps.sh

@@ -236,16 +236,18 @@ install_libexpat() {
   fi
 }
 
-install_webrtc79(){
-  $INCR_INSTALL &&  [[ -s $ROOT/third_party/webrtc-m79/libwebrtc.a ]] && \
+install_webrtc88(){
+  local OWT_WEBRTC_PATH="$ROOT/third_party/webrtc-m88"
+
+  $INCR_INSTALL &&  [[ -s $OWT_WEBRTC_PATH/libwebrtc.a ]] && \
   echo "libwebrtc already installed." && return 0
 
-  [[ ! -d $ROOT/third_party/webrtc-m79 ]] && \
-    mkdir $ROOT/third_party/webrtc-m79
+  [[ ! -d $OWT_WEBRTC_PATH ]] && \
+    mkdir $OWT_WEBRTC_PATH
 
-  pushd ${ROOT}/third_party/webrtc-m79 >/dev/null
-  . $PATHNAME/installWebrtc.sh
-  popd
+  pushd $OWT_WEBRTC_PATH >/dev/null
+   . $PATHNAME/installWebrtc.sh
+  popd >/dev/null
 }
 
 install_webrtc(){
@@ -272,7 +274,7 @@ install_webrtc(){
   ./src/tools-woogeen/build.sh
   popd
 
-  install_webrtc79
+  install_webrtc88
 }
 
 install_licode(){

scripts/installWebrtc.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -e
 
-SSL_GNI=$(cat <<-END
+GNI_APPEND=$(cat <<-END
 declare_args() {
   build_with_owt = false
   owt_use_openssl = false
@@ -29,6 +29,7 @@ END
 # comment is_debug=false for debugging
 GN_ARGS=$(cat <<-END
 rtc_use_h264=true
+rtc_use_h265=true
 ffmpeg_branding="Chrome"
 is_component_build=false
 use_lld=false
@@ -41,6 +42,7 @@ is_clang=false
 treat_warnings_as_errors=false
 rtc_enable_libevent=false
 rtc_build_libevent=false
+fatal_linker_warnings=false
 is_debug=false
 
 END
@@ -68,9 +70,13 @@ download_and_build(){
   if [ -d src ]; then
     echo "src already exists."
   else
-    git clone -b 79-sdk https://github.com/open-webrtc-toolkit/owt-deps-webrtc.git src
+    git clone -b 88-sdk https://github.com/open-webrtc-toolkit/owt-deps-webrtc.git src
+    pushd src >/dev/null
+    git reset --hard 0d230afe9c7a968c0f2d966ef9d4d396fee489bf
+    popd >/dev/null
     mkdir -p src/build_overrides/ssl
-    echo $SSL_GNI > src/build_overrides/ssl/ssl.gni
+    echo "" > src/build_overrides/ssl/ssl.gni
+    echo $GNI_APPEND >> src/build_overrides/build.gni
     echo $GCLIENT_CONFIG > .gclient
   fi
 
@@ -81,7 +87,7 @@ download_and_build(){
 
   export PATH="$PATH:$DEPOT_TOOLS"
   gclient sync  --no-history
-  pushd src >/dev/null  
+  pushd src >/dev/null
   gn gen out --args="$GN_ARGS"
   ninja -C out call default_task_queue_factory
   all=`find ./out/obj/ -name "*.o"`

source/agent/webrtc/rtcFrame/binding.gyp

@@ -63,7 +63,7 @@
     'variables': {
       'source_rel_dir': '../../..', # relative source dir path
       'source_abs_dir%': '<(module_root_dir)/../../..', # absolute source dir path
-      'webrtc_abs_dir%': '<(module_root_dir)/../../../../third_party/webrtc-m79' # absolute webrtc dir path
+      'webrtc_abs_dir%': '<(module_root_dir)/../../../../third_party/webrtc-m88' # absolute webrtc dir path
     },
     'sources': [
         '<(source_rel_dir)/core/rtc_adapter/RtcAdapter.cc',

source/core/owt_base/SsrcGenerator.cc

@@ -14,24 +14,29 @@ SsrcGenerator* SsrcGenerator::GetSsrcGenerator() {
 }
 
 uint32_t SsrcGenerator::CreateSsrc() {
-  rtc::CritScope lock(&crit_);
+  mutex_.Lock();
 
   while (true) {  // Try until get a new ssrc.
     uint32_t ssrc = random_.Rand(1u, 0xfffffffe);
     if (ssrcs_.insert(ssrc).second) {
+      mutex_.Unlock();
       return ssrc;
     }
   }
+  mutex_.Unlock();
 }
 
 void SsrcGenerator::RegisterSsrc(uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  mutex_.Lock();
   ssrcs_.insert(ssrc);
+  mutex_.Unlock();
+
 }
 
 void SsrcGenerator::ReturnSsrc(uint32_t ssrc) {
-  rtc::CritScope lock(&crit_);
+  mutex_.Lock();
   ssrcs_.erase(ssrc);
+  mutex_.Unlock();
 }
 
 SsrcGenerator::SsrcGenerator() : random_(rtc::TimeMicros()) {}

source/core/owt_base/SsrcGenerator.h

@@ -7,9 +7,9 @@
 
 #include <set>
 
-#include "rtc_base/critical_section.h"
 #include "rtc_base/random.h"
-#include "base/thread_annotations.h"
+#include "rtc_base/synchronization/mutex.h"
+#include "rtc_base/thread_annotations.h"
 
 namespace owt_base {
 
@@ -26,9 +26,9 @@ class SsrcGenerator {
   ~SsrcGenerator();
 
  private:
-  rtc::CriticalSection crit_;
-  webrtc::Random random_ GUARDED_BY(crit_);
-  std::set<uint32_t> ssrcs_ GUARDED_BY(crit_);
+  mutable webrtc::Mutex mutex_;
+  webrtc::Random random_ RTC_GUARDED_BY(mutex_);
+  std::set<uint32_t> ssrcs_ RTC_GUARDED_BY(mutex_);
 };
 }  // namespace owt_base
 

source/core/rtc_adapter/RtcAdapter.cc

@@ -14,6 +14,7 @@
 #include <mutex>
 
 #include <system_wrappers/include/clock.h>
+#include <system_wrappers/include/field_trial.h>
 
 namespace rtc_adapter {
 
@@ -37,10 +38,26 @@ class RTCProcessThread {
     std::unique_ptr<webrtc::ProcessThread> m_processThread;
 };
 
-static std::unique_ptr<RTCProcessThread> g_moduleThread
-    = std::make_unique<RTCProcessThread>("ModuleProcessThread");
-static std::unique_ptr<RTCProcessThread> g_pacerThread
-    = std::make_unique<RTCProcessThread>("PacerThread");
+static rtc::scoped_refptr<webrtc::SharedModuleThread> g_moduleThread;
+
+static std::unique_ptr<RTCProcessThread> g_pacerThread;
+
+static std::unique_ptr<webrtc::FieldTrialBasedConfig> g_fieldTrial= []()
+{
+    auto config = std::make_unique<webrtc::FieldTrialBasedConfig>();
+    // webrtc::field_trial::InitFieldTrialsFromString("WebRTC-TaskQueuePacer/Enabled/");
+    return config;
+}();
+
+static std::shared_ptr<webrtc::RtcEventLog> g_eventLog =
+    std::make_shared<webrtc::RtcEventLogNull>();
+
+static std::shared_ptr<webrtc::TaskQueueFactory> g_taskQueueFactory =
+    createStaticTaskQueueFactory();
+static std::shared_ptr<rtc::TaskQueue> g_taskQueue =
+    std::make_shared<rtc::TaskQueue>(g_taskQueueFactory->CreateTaskQueue(
+        "CallTaskQueue",
+        webrtc::TaskQueueFactory::Priority::NORMAL));
 
 class RtcAdapterImpl : public RtcAdapter,
                        public CallOwner {
@@ -58,52 +75,67 @@ class RtcAdapterImpl : public RtcAdapter,
     AudioSendAdapter* createAudioSender(const Config&) override;
     void destoryAudioSender(AudioSendAdapter*) override;
 
+
+    typedef std::shared_ptr<webrtc::Call> CallPtr;
+
     // Implement CallOwner
-    std::shared_ptr<webrtc::Call> call() override { return m_call; }
+    std::shared_ptr<webrtc::Call> call() override
+    {
+        return m_callPtr ? (*m_callPtr) : nullptr;
+    }
     std::shared_ptr<webrtc::TaskQueueFactory> taskQueueFactory() override
     {
-        return m_taskQueueFactory;
+        return g_taskQueueFactory;
     }
-    std::shared_ptr<rtc::TaskQueue> taskQueue() override { return m_taskQueue; }
-    std::shared_ptr<webrtc::RtcEventLog> eventLog() override { return m_eventLog; }
+    std::shared_ptr<rtc::TaskQueue> taskQueue() override { return g_taskQueue; }
+    std::shared_ptr<webrtc::RtcEventLog> eventLog() override { return g_eventLog; }
 
 private:
     void initCall();
 
-    std::shared_ptr<webrtc::TaskQueueFactory> m_taskQueueFactory;
-    std::shared_ptr<rtc::TaskQueue> m_taskQueue;
-    std::shared_ptr<webrtc::RtcEventLog> m_eventLog;
-    std::shared_ptr<webrtc::Call> m_call;
+    std::shared_ptr<CallPtr> m_callPtr;
 };
 
 RtcAdapterImpl::RtcAdapterImpl()
-    : m_taskQueueFactory(createStaticTaskQueueFactory())
-    , m_taskQueue(std::make_shared<rtc::TaskQueue>(m_taskQueueFactory->CreateTaskQueue(
-          "CallTaskQueue",
-          webrtc::TaskQueueFactory::Priority::NORMAL)))
-    , m_eventLog(std::make_shared<webrtc::RtcEventLogNull>())
 {
 }
 
 RtcAdapterImpl::~RtcAdapterImpl()
 {
+    if (m_callPtr) {
+        std::shared_ptr<CallPtr> pCallPtr = m_callPtr;
+        m_callPtr.reset();
+        g_taskQueue->PostTask([pCallPtr]() {
+            if (*pCallPtr) {
+                (*pCallPtr).reset();
+            }
+        });
+    }
 }
 
 void RtcAdapterImpl::initCall()
 {
-    m_taskQueue->PostTask([this]() {
+    m_callPtr.reset(new CallPtr());
+    std::shared_ptr<CallPtr> pCallPtr = m_callPtr;
+    g_taskQueue->PostTask([pCallPtr]() {
         // Initialize call
-        if (!m_call) {
-            webrtc::Call::Config call_config(m_eventLog.get());
-            call_config.task_queue_factory = m_taskQueueFactory.get();
+        if (!(*pCallPtr)) {
+            webrtc::Call::Config call_config(g_eventLog.get());
+            call_config.task_queue_factory = g_taskQueueFactory.get();
+            call_config.trials = g_fieldTrial.get();
+
+            if (!g_moduleThread) {
+                g_moduleThread = webrtc::SharedModuleThread::Create(
+                    webrtc::ProcessThread::Create("ModuleProcessThread"), nullptr);
+            }
 
-            std::unique_ptr<webrtc::ProcessThread> moduleThreadProxy =
-                std::make_unique<ProcessThreadProxy>(g_moduleThread->unwrap());
+            // Empty thread for pacer
             std::unique_ptr<webrtc::ProcessThread> pacerThreadProxy =
-                std::make_unique<ProcessThreadProxy>(g_pacerThread->unwrap());
-            m_call.reset(webrtc::Call::Create(
+                std::make_unique<ProcessThreadProxy>(nullptr);
+
+            (*pCallPtr).reset(webrtc::Call::Create(
                 call_config, webrtc::Clock::GetRealTimeClock(),
-                std::move(moduleThreadProxy),
+                g_moduleThread,
                 std::move(pacerThreadProxy)));
         }
     });

source/core/rtc_adapter/VideoReceiveAdapter.cc

@@ -4,7 +4,6 @@
 
 #include "VideoReceiveAdapter.h"
 
-#include <common_types.h>
 #include <future>
 #include <modules/video_coding/include/video_error_codes.h>
 #include <modules/video_coding/timing.h>
@@ -210,6 +209,7 @@ void VideoReceiveAdapterImpl::CreateReceiveVideo()
             default_config.renderer = this;
 
             webrtc::VideoReceiveStream::Config video_recv_config(default_config.Copy());
+            video_recv_config.decoder_factory = this;
             video_recv_config.decoders.clear();
             /*
             if (!video_send_config.rtp.rtx.ssrcs.empty()) {
@@ -219,7 +219,6 @@ void VideoReceiveAdapterImpl::CreateReceiveVideo()
             }
             */
             webrtc::VideoReceiveStream::Decoder decoder;
-            decoder.decoder_factory = this;
             // Add VP8 decoder
             decoder.payload_type = VP8_90000_PT;
             decoder.video_format = webrtc::SdpVideoFormat(