Enable NACK module.

Author: jianjunz

talk/owt/sdk/wasm/binding.h

@@ -15,8 +15,8 @@ namespace wasm {
 EMSCRIPTEN_BINDINGS(Owt) {
   emscripten::class_<MediaSession>("MediaSession")
       .constructor<>()
-      .function("createRtpVideoReceiver",
-                &MediaSession::CreateRtpVideoReceiver);
+      .function("createRtpVideoReceiver", &MediaSession::CreateRtpVideoReceiver)
+      .function("setRtcpCallback", &MediaSession::SetRtcpCallback);
   emscripten::class_<RtpVideoReceiver>("RtpVideoReceiver")
       .smart_ptr<std::shared_ptr<RtpVideoReceiver>>("RtpVideoReceiver")
       .function("onRtpPacket", &RtpVideoReceiver::OnRtpPacket,

talk/owt/sdk/wasm/gn/wasm.gni

@@ -66,8 +66,11 @@ template("wasm_lib") {
       "MEMFS_APPEND_TO_TYPED_ARRAYS=1",
 
       # Reduces global namespace pollution.
-      # "-s",
-      # "MODULARIZE=1",
+      "-s",
+      "MODULARIZE=1",
+
+      "-s",
+      "EXPORT_ES6=1",
 
       #"-fno-stack-protector",
 
@@ -81,7 +84,7 @@ template("wasm_lib") {
       "--bind",
 
       "-s",
-      "PTHREAD_POOL_SIZE=2",
+      "PTHREAD_POOL_SIZE=5",
 
       "-pthread",
 

talk/owt/sdk/wasm/media_session.cc

@@ -20,28 +20,52 @@ MediaSession::MediaSession()
       receive_statistics_(
           webrtc::ReceiveStatistics::Create(webrtc::Clock::GetRealTimeClock())),
       receiver_process_thread_(nullptr),
-      video_receiver_(nullptr) {
-  RTC_LOG(LS_ERROR) << "Ctor of Media Session. " << __EMSCRIPTEN_PTHREADS__;
+      video_receiver_(nullptr),
+      rtcp_callback_(emscripten::val::null()) {
   rtc::ThreadManager::Instance()->WrapCurrentThread();
-  receiver_process_thread_=webrtc::ProcessThread::Create("ReceiverProcessThread");
+  receiver_process_thread_ =
+      webrtc::ProcessThread::Create("ReceiverProcessThread");
   webrtc::Call::Config config(event_log_.get());
   config.task_queue_factory = task_queue_factory_.get();
   webrtc::FieldTrialBasedConfig trials;
   config.trials = &trials;
   call_ = std::unique_ptr<webrtc::Call>(webrtc::Call::Create(config));
 }
 
-MediaSession::~MediaSession() {}
-
 std::shared_ptr<RtpVideoReceiver> MediaSession::CreateRtpVideoReceiver() {
-  webrtc::VideoReceiveStream::Config config(web_transport_session_.get());
+  webrtc::VideoReceiveStream::Config config(this);
   config.rtp.local_ssrc = 1;
-  // TODO: Get a message queue for receiver.
+  // Same as `kNackRtpHistoryMs` in third_party/webrtc/media/engine/webrtc_voice_engine.cc.
+  config.rtp.nack.rtp_history_ms = 5000;
+  // TODO: Use call_->worker_thread() when libwebrtc is rolled to a newer version.
+  webrtc::TaskQueueBase* current = webrtc::TaskQueueBase::Current();
+  if (!current)
+    current = rtc::ThreadManager::Instance()->CurrentThread();
+  RTC_DCHECK(current);
   video_receiver_ = std::make_shared<RtpVideoReceiver>(
-      web_transport_session_.get(), &config, receive_statistics_.get(),
-      receiver_process_thread_.get(), web_transport_session_.get());
+      current, this, &config, receive_statistics_.get(),
+      receiver_process_thread_.get());
   return video_receiver_;
 }
 
+void MediaSession::SetRtcpCallback(emscripten::val callback) {
+  rtcp_callback_ = callback;
+}
+
+bool MediaSession::SendRtp(const uint8_t* packet,
+                           size_t length,
+                           const webrtc::PacketOptions& options) {
+  return false;
+}
+
+bool MediaSession::SendRtcp(const uint8_t* packet, size_t length) {
+  if (!rtcp_callback_) {
+    return false;
+  }
+  emscripten::val buffer(emscripten::typed_memory_view(length, packet));
+  rtcp_callback_(buffer);
+  return true;
+}
+
 }  // namespace wasm
 }  // namespace owt

talk/owt/sdk/wasm/media_session.h

@@ -5,6 +5,7 @@
 #ifndef OWT_WASM_MEDIASESSION_H_
 #define OWT_WASM_MEDIASESSION_H_
 
+#include <emscripten/bind.h>
 #include "call/call.h"
 #include "talk/owt/sdk/wasm/rtp_video_receiver.h"
 #include "talk/owt/sdk/wasm/web_transport_session.h"
@@ -13,11 +14,18 @@
 namespace owt {
 namespace wasm {
 // Manages a media session between a web client and OWT server QUIC agent.
-class MediaSession {
+class MediaSession : public webrtc::Transport {
  public:
   explicit MediaSession();
-  virtual ~MediaSession();
+  virtual ~MediaSession() = default;
   std::shared_ptr<RtpVideoReceiver> CreateRtpVideoReceiver();
+  void SetRtcpCallback(emscripten::val callback);
+
+  // Overrides webrtc::Transport.
+  bool SendRtp(const uint8_t* packet,
+               size_t length,
+               const webrtc::PacketOptions& options) override;
+  bool SendRtcp(const uint8_t* packet, size_t length) override;
 
  private:
   std::unique_ptr<webrtc::TaskQueueFactory> task_queue_factory_;
@@ -28,6 +36,7 @@ class MediaSession {
   std::unique_ptr<webrtc::ReceiveStatistics> receive_statistics_;
   std::unique_ptr<webrtc::ProcessThread> receiver_process_thread_;
   std::shared_ptr<RtpVideoReceiver> video_receiver_;
+  emscripten::val rtcp_callback_;
 };
 
 }  // namespace wasm

talk/owt/sdk/wasm/rtp_video_receiver.cc

@@ -10,16 +10,16 @@ namespace owt {
 namespace wasm {
 
 RtpVideoReceiver::RtpVideoReceiver(
+    webrtc::TaskQueueBase* current_queue,
     webrtc::Transport* transport,
     const webrtc::VideoReceiveStream::Config* config,
     webrtc::ReceiveStatistics* rtp_receive_statistics,
-    webrtc::ProcessThread* process_thread,
-    webrtc::NackSender* nack_sender)
+    webrtc::ProcessThread* process_thread)
     : receiver_(nullptr), complete_frame_callback_(emscripten::val::null()) {
   receiver_ = std::make_unique<webrtc::RtpVideoStreamReceiver2>(
-      nullptr, webrtc::Clock::GetRealTimeClock(), transport, nullptr, nullptr,
-      config, rtp_receive_statistics, nullptr, nullptr, process_thread,
-      nack_sender, nullptr, this, nullptr, nullptr);
+      current_queue, webrtc::Clock::GetRealTimeClock(), transport, nullptr,
+      nullptr, config, rtp_receive_statistics, nullptr, nullptr, process_thread,
+      this, nullptr, this, nullptr, nullptr);
   webrtc::VideoCodec codec;
   codec.codecType = webrtc::VideoCodecType::kVideoCodecH264;
   // TODO: Assign payload value dynamically according to server side
@@ -53,5 +53,14 @@ void RtpVideoReceiver::SetCompleteFrameCallback(emscripten::val callback) {
   complete_frame_callback_ = callback;
 }
 
+void RtpVideoReceiver::SendNack(const std::vector<uint16_t>& sequence_numbers,
+                                bool buffering_allowed) {
+  // Only buffering_allowed == true is supported. Same as
+  // https://source.chromium.org/chromium/chromium/src/+/main:third_party/webrtc/video/video_receive_stream2.h;l=157;bpv=1;bpt=1
+  RTC_DCHECK(buffering_allowed);
+  RTC_LOG(LS_INFO)<<"Request packet rtx";
+  receiver_->RequestPacketRetransmit(sequence_numbers);
+}
+
 }  // namespace wasm
 }  // namespace owt

talk/owt/sdk/wasm/rtp_video_receiver.h

@@ -11,13 +11,14 @@
 namespace owt {
 namespace wasm {
 class RtpVideoReceiver
-    : public webrtc::RtpVideoStreamReceiver2::OnCompleteFrameCallback {
+    : public webrtc::RtpVideoStreamReceiver2::OnCompleteFrameCallback,
+      public webrtc::NackSender {
  public:
-  explicit RtpVideoReceiver(webrtc::Transport* transport,
+  explicit RtpVideoReceiver(webrtc::TaskQueueBase* current_queue,
+                            webrtc::Transport* transport,
                             const webrtc::VideoReceiveStream::Config* config,
                             webrtc::ReceiveStatistics* rtp_receive_statistics,
-                            webrtc::ProcessThread* process_thread,
-                            webrtc::NackSender* nack_sender);
+                            webrtc::ProcessThread* process_thread);
   virtual ~RtpVideoReceiver() {}
   virtual bool OnRtpPacket(uintptr_t packet_ptr, size_t packet_size);
 
@@ -27,6 +28,10 @@ class RtpVideoReceiver
 
   void SetCompleteFrameCallback(emscripten::val callback);
 
+  // Overrides webrtc::NackSender.
+  void SendNack(const std::vector<uint16_t>& sequence_numbers,
+                bool buffering_allowed) override;
+
  private:
   std::unique_ptr<webrtc::RtpVideoStreamReceiver2> receiver_;
   emscripten::val complete_frame_callback_;