Upgrade sdk to m88 for webrtc node

Author: starwarfan

scripts/installWebrtc.sh

@@ -68,7 +68,7 @@ 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
     mkdir -p src/build_overrides/ssl
     echo $SSL_GNI > src/build_overrides/ssl/ssl.gni
     echo $GCLIENT_CONFIG > .gclient

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/synchronization/mutex.h"
+#include "rtc_base/thread_annotations.h"
 #include "rtc_base/random.h"
-#include "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

@@ -37,11 +37,16 @@ class RTCProcessThread {
     std::unique_ptr<webrtc::ProcessThread> m_processThread;
 };
 
-static std::unique_ptr<RTCProcessThread> g_moduleThread
-    = std::make_unique<RTCProcessThread>("ModuleProcessThread");
+static rtc::scoped_refptr<webrtc::SharedModuleThread> g_moduleThread =
+    webrtc::SharedModuleThread::Create(
+        webrtc::ProcessThread::Create("ModuleProcessThread"), nullptr);
+
 static std::unique_ptr<RTCProcessThread> g_pacerThread
     = std::make_unique<RTCProcessThread>("PacerThread");
 
+static std::unique_ptr<webrtc::FieldTrialBasedConfig> g_fieldTrial=
+    std::make_unique<webrtc::FieldTrialBasedConfig>();
+
 class RtcAdapterImpl : public RtcAdapter,
                        public CallOwner {
 public:
@@ -96,14 +101,13 @@ void RtcAdapterImpl::initCall()
         if (!m_call) {
             webrtc::Call::Config call_config(m_eventLog.get());
             call_config.task_queue_factory = m_taskQueueFactory.get();
+            call_config.trials = g_fieldTrial.get();
 
-            std::unique_ptr<webrtc::ProcessThread> moduleThreadProxy =
-                std::make_unique<ProcessThreadProxy>(g_moduleThread->unwrap());
             std::unique_ptr<webrtc::ProcessThread> pacerThreadProxy =
                 std::make_unique<ProcessThreadProxy>(g_pacerThread->unwrap());
             m_call.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(

source/core/rtc_adapter/VideoSendAdapter.cc

@@ -179,6 +179,12 @@ bool VideoSendAdapterImpl::init()
     configuration.event_log = m_eventLog.get();
     configuration.retransmission_rate_limiter = m_retransmissionRateLimiter.get();
     configuration.local_media_ssrc = m_ssrc; //rtp_config.ssrcs[i];
+    // TODO: enable UlpfecGenerator
+    /*
+    std::make_unique<UlpfecGenerator>(
+        rtp.ulpfec.red_payload_type, rtp.ulpfec.ulpfec_payload_type, clock);
+    configuration.fec_generator = fec_generator.get();
+    */
 
     m_rtpRtcp = webrtc::RtpRtcp::Create(configuration);
     m_rtpRtcp->SetSendingStatus(true);
@@ -202,21 +208,15 @@ bool VideoSendAdapterImpl::init()
     m_rtpRtcp->SetMaxRtpPacketSize(kMaxRtpPacketSize);
 
     webrtc::RTPSenderVideo::Config video_config;
-    m_playoutDelayOracle = std::make_unique<webrtc::PlayoutDelayOracle>();
     m_fieldTrialConfig = std::make_unique<webrtc::FieldTrialBasedConfig>();
     video_config.clock = configuration.clock;
     video_config.rtp_sender = m_rtpRtcp->RtpSender();
     video_config.field_trials = m_fieldTrialConfig.get();
-    video_config.playout_delay_oracle = m_playoutDelayOracle.get();
     if (m_config.red_payload) {
         video_config.red_payload_type = m_config.red_payload;
     }
-    if (m_config.ulpfec_payload) {
-        video_config.ulpfec_payload_type = m_config.ulpfec_payload;
-    }
 
     m_senderVideo = std::make_unique<webrtc::RTPSenderVideo>(video_config);
-    // m_params = std::make_unique<RtpPayloadParams>(m_ssrc, nullptr);
     m_taskRunner->RegisterModule(m_rtpRtcp.get());
 
     return true;
@@ -279,9 +279,9 @@ void VideoSendAdapterImpl::onFrame(const Frame& frame)
             timeStamp,
             timeStamp,
             rtc::ArrayView<const uint8_t>(frame.payload, frame.length),
-            nullptr,
             h,
-            m_rtpRtcp->ExpectedRetransmissionTimeMs());
+            m_rtpRtcp->ExpectedRetransmissionTimeMs(),
+            0);
     } else if (frame.format == FRAME_FORMAT_VP9) {
         h.codec = webrtc::VideoCodecType::kVideoCodecVP9;
         auto& vp9_header = h.video_type_header.emplace<RTPVideoHeaderVP9>();
@@ -294,9 +294,10 @@ void VideoSendAdapterImpl::onFrame(const Frame& frame)
             timeStamp,
             timeStamp,
             rtc::ArrayView<const uint8_t>(frame.payload, frame.length),
-            nullptr,
             h,
-            m_rtpRtcp->ExpectedRetransmissionTimeMs());
+            m_rtpRtcp->ExpectedRetransmissionTimeMs(),
+            0);
+
     } else if (frame.format == FRAME_FORMAT_H264 || frame.format == FRAME_FORMAT_H265) {
         int frame_length = frame.length;
         if (m_enableDump) {
@@ -315,24 +316,10 @@ void VideoSendAdapterImpl::onFrame(const Frame& frame)
         int nalu_start_offset = 0;
         int nalu_end_offset = 0;
         int sc_len = 0;
-        RTPFragmentationHeader frag_info;
-
-        h.codec = (frame.format == FRAME_FORMAT_H264) ? webrtc::VideoCodecType::kVideoCodecH264 : webrtc::VideoCodecType::kVideoCodecH265;
-        while (buffer_length > 0) {
-            nalu_found_length = findNALU(buffer_start, buffer_length, &nalu_start_offset, &nalu_end_offset, &sc_len);
-            if (nalu_found_length < 0) {
-                /* Error, should never happen */
-                break;
-            } else {
-                /* SPS, PPS, I, P*/
-                uint16_t last = frag_info.fragmentationVectorSize;
-                frag_info.VerifyAndAllocateFragmentationHeader(last + 1);
-                frag_info.fragmentationOffset[last] = nalu_start_offset + (buffer_start - frame.payload);
-                frag_info.fragmentationLength[last] = nalu_found_length;
-                buffer_start += (nalu_start_offset + nalu_found_length);
-                buffer_length -= (nalu_start_offset + nalu_found_length);
-            }
-        }
+
+        h.codec = (frame.format == FRAME_FORMAT_H264) ?
+            webrtc::VideoCodecType::kVideoCodecH264 :
+            webrtc::VideoCodecType::kVideoCodecH265;
 
         boost::shared_lock<boost::shared_mutex> lock(m_rtpRtcpMutex);
         if (frame.format == FRAME_FORMAT_H264) {
@@ -343,9 +330,9 @@ void VideoSendAdapterImpl::onFrame(const Frame& frame)
                 timeStamp,
                 timeStamp,
                 rtc::ArrayView<const uint8_t>(frame.payload, frame.length),
-                &frag_info,
                 h,
-                m_rtpRtcp->ExpectedRetransmissionTimeMs());
+                m_rtpRtcp->ExpectedRetransmissionTimeMs(),
+                0);
         } else {
             h.video_type_header.emplace<RTPVideoHeaderH265>();
             m_senderVideo->SendVideo(
@@ -354,9 +341,9 @@ void VideoSendAdapterImpl::onFrame(const Frame& frame)
                 timeStamp,
                 timeStamp,
                 rtc::ArrayView<const uint8_t>(frame.payload, frame.length),
-                &frag_info,
                 h,
-                m_rtpRtcp->ExpectedRetransmissionTimeMs());
+                m_rtpRtcp->ExpectedRetransmissionTimeMs(),
+                0);
         }
     }
 }

source/core/rtc_adapter/VideoSendAdapter.h

@@ -82,7 +82,6 @@ class VideoSendAdapterImpl : public VideoSendAdapter,
 
     std::unique_ptr<webrtc::RtcEventLog> m_eventLog;
     std::unique_ptr<webrtc::RTPSenderVideo> m_senderVideo;
-    std::unique_ptr<webrtc::PlayoutDelayOracle> m_playoutDelayOracle;
     std::unique_ptr<webrtc::FieldTrialBasedConfig> m_fieldTrialConfig;
 
     // Listeners

source/core/rtc_adapter/thread/ProcessThreadProxy.h

@@ -27,20 +27,31 @@ class ProcessThreadProxy : public webrtc::ProcessThread {
     // Stop() has no effect on proxy
     virtual void Stop() override {}
 
+    // Implements webrtc::TaskQueueBase
+    virtual void Delete() override {}
+
     // Implements ProcessThread
     // Call actual ProcessThread's WakeUp
     virtual void WakeUp(webrtc::Module* module) override
     {
         m_processThread->WakeUp(module);
     }
 
-    // Implements ProcessThread
+    // Implements webrtc::TaskQueueBase
     // Call actual ProcessThread's PostTask
     virtual void PostTask(std::unique_ptr<webrtc::QueuedTask> task) override
     {
         m_processThread->PostTask(std::move(task));
     }
 
+    // Implements webrtc::TaskQueueBase
+    // Call actual ProcessThread's PostDelayedTask
+    virtual void PostDelayedTask(std::unique_ptr<webrtc::QueuedTask> task,
+                                 uint32_t milliseconds) override
+    {
+        m_processThread->PostDelayedTask(std::move(task), milliseconds);
+    }
+
     // Implements ProcessThread
     // Call actual ProcessThread's RegisterModule
     virtual void RegisterModule(webrtc::Module* module, const rtc::Location& from) override