Parse FlexFEC RTP headers in Call and add integration with BWE.

webrtc/call/call.cc

 /*
  *  Copyright (c) 2013 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.
  */
 
 #include <string.h>
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "webrtc/audio/audio_receive_stream.h"
 #include "webrtc/audio/audio_send_stream.h"
 #include "webrtc/audio/audio_state.h"
 #include "webrtc/audio/scoped_voe_interface.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/base/optional.h"
 #include "webrtc/base/task_queue.h"
 #include "webrtc/base/thread_annotations.h"
 #include "webrtc/base/thread_checker.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/call/bitrate_allocator.h"
 #include "webrtc/call/call.h"
 #include "webrtc/call/flexfec_receive_stream.h"
 #include "webrtc/config.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/pacing/paced_sender.h"
 #include "webrtc/modules/rtp_rtcp/include/flexfec_receiver.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_header_parser.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extension.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "webrtc/modules/rtp_rtcp/source/rtp_packet_received.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/cpu_info.h"
 #include "webrtc/system_wrappers/include/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/system_wrappers/include/rw_lock_wrapper.h"
 #include "webrtc/system_wrappers/include/trace.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/send_delay_stats.h"
 #include "webrtc/video/stats_counter.h"
@@ skipping 48 matching lines @@
 
   // Implements PacketReceiver.
   DeliveryStatus DeliverPacket(MediaType media_type,
                                const uint8_t* packet,
                                size_t length,
                                const PacketTime& packet_time) override;
 
   // Implements RecoveredPacketReceiver.
   bool OnRecoveredPacket(const uint8_t* packet, size_t length) override;
 
+  void NotifyBweOfReceivedPacket(const RtpPacketReceived& packet);
+
   void SetBitrateConfig(
       const webrtc::Call::Config::BitrateConfig& bitrate_config) override;
 
   void SignalChannelNetworkState(MediaType media, NetworkState state) override;
 
   void OnTransportOverheadChanged(MediaType media,
                                   int transport_overhead_per_packet) override;
 
   void OnNetworkRouteChanged(const std::string& transport_name,
                              const rtc::NetworkRoute& network_route) override;
@@ skipping 27 matching lines @@
 
   VoiceEngine* voice_engine() {
     internal::AudioState* audio_state =
         static_cast<internal::AudioState*>(config_.audio_state.get());
     if (audio_state)
       return audio_state->voice_engine();
     else
       return nullptr;
   }
 
+  rtc::Optional<RtpPacketReceived> ParseRtpPacket(const uint8_t* packet,
+                                                  size_t length,
+                                                  const PacketTime& packet_time)
+      SHARED_LOCKS_REQUIRED(receive_crit_);
+
   void UpdateSendHistograms() EXCLUSIVE_LOCKS_REQUIRED(&bitrate_crit_);
   void UpdateReceiveHistograms();
   void UpdateHistograms();
   void UpdateAggregateNetworkState();
 
   Clock* const clock_;
 
   const int num_cpu_cores_;
   const std::unique_ptr<ProcessThread> module_process_thread_;
   const std::unique_ptr<ProcessThread> pacer_thread_;
@@ skipping 18 matching lines @@
   // streams.
   std::multimap<uint32_t, FlexfecReceiveStream*> flexfec_receive_ssrcs_media_
       GUARDED_BY(receive_crit_);
   std::map<uint32_t, FlexfecReceiveStream*> flexfec_receive_ssrcs_protection_
       GUARDED_BY(receive_crit_);
   std::set<FlexfecReceiveStream*> flexfec_receive_streams_
       GUARDED_BY(receive_crit_);
   std::map<std::string, AudioReceiveStream*> sync_stream_mapping_
       GUARDED_BY(receive_crit_);
 
+  // Registered RTP header extensions for each stream.
+  // Note that RTP header extensions are negotiated per track ("m= line") in the
+  // SDP, but we have no notion of tracks at the Call level. We therefore store
+  // the RTP header extensions per SSRC instead, which leads to some storage
+  // overhead.
+  std::map<uint32_t, RtpHeaderExtensionMap> received_rtp_header_extensions_
+      GUARDED_BY(receive_crit_);
+
   std::unique_ptr<RWLockWrapper> send_crit_;
   // Audio and Video send streams are owned by the client that creates them.
   std::map<uint32_t, AudioSendStream*> audio_send_ssrcs_ GUARDED_BY(send_crit_);
   std::map<uint32_t, VideoSendStream*> video_send_ssrcs_ GUARDED_BY(send_crit_);
   std::set<VideoSendStream*> video_send_streams_ GUARDED_BY(send_crit_);
 
   VideoSendStream::RtpStateMap suspended_video_send_ssrcs_;
   webrtc::RtcEventLog* event_log_;
 
   // The following members are only accessed (exclusively) from one thread and
@@ skipping 14 matching lines @@
   AvgCounter pacer_bitrate_kbps_counter_ GUARDED_BY(&bitrate_crit_);
 
   std::map<std::string, rtc::NetworkRoute> network_routes_;
 
   VieRemb remb_;
   PacketRouter packet_router_;
   // TODO(nisse): Could be a direct member, except for constness
   // issues with GetRemoteBitrateEstimator (and maybe others).
   const std::unique_ptr<CongestionController> congestion_controller_;
   const std::unique_ptr<SendDelayStats> video_send_delay_stats_;
+  // Cached results from congestion_controller_->GetRemoteBitrateEstimator.
+  // Currently only used by FlexFEC in ParseRtpPacket.
+  RemoteBitrateEstimator* const remote_bitrate_estimator_;
+  RemoteBitrateEstimator* const remote_estimator_proxy_;  // Send-side BWE.
   const int64_t start_ms_;
   // TODO(perkj): |worker_queue_| is supposed to replace
   // |module_process_thread_|.
   // |worker_queue| is defined last to ensure all pending tasks are cancelled
   // and deleted before any other members.
   rtc::TaskQueue worker_queue_;
 
   RTC_DISALLOW_COPY_AND_ASSIGN(Call);
 };
 }  // namespace internal
@@ skipping 38 matching lines @@
       configured_max_padding_bitrate_bps_(0),
       estimated_send_bitrate_kbps_counter_(clock_, nullptr, true),
       pacer_bitrate_kbps_counter_(clock_, nullptr, true),
       remb_(clock_),
       congestion_controller_(new CongestionController(clock_,
                                                       this,
                                                       &remb_,
                                                       event_log_,
                                                       &packet_router_)),
       video_send_delay_stats_(new SendDelayStats(clock_)),
+      remote_bitrate_estimator_(
+          congestion_controller_->GetRemoteBitrateEstimator(false)),
+      remote_estimator_proxy_(
+          congestion_controller_->GetRemoteBitrateEstimator(true)),
       start_ms_(clock_->TimeInMilliseconds()),
       worker_queue_("call_worker_queue") {
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   RTC_DCHECK(config.event_log != nullptr);
   RTC_DCHECK_GE(config.bitrate_config.min_bitrate_bps, 0);
   RTC_DCHECK_GE(config.bitrate_config.start_bitrate_bps,
                 config.bitrate_config.min_bitrate_bps);
   if (config.bitrate_config.max_bitrate_bps != -1) {
     RTC_DCHECK_GE(config.bitrate_config.max_bitrate_bps,
                   config.bitrate_config.start_bitrate_bps);
@@ skipping 41 matching lines @@
   {
     rtc::CritScope lock(&bitrate_crit_);
     UpdateSendHistograms();
   }
   UpdateReceiveHistograms();
   UpdateHistograms();
 
   Trace::ReturnTrace();
 }
 
+rtc::Optional<RtpPacketReceived> Call::ParseRtpPacket(
+    const uint8_t* packet,
+    size_t length,
+    const PacketTime& packet_time) {
+  RtpPacketReceived parsed_packet(nullptr);

[danilchap, 2016/12/15 10:23:47]

sorry for incomplete previous comment, there is actually a default constructor
for RtpPacketReceived that looks more suitable here.

[brandtr, 2016/12/16 12:48:52]

Done.

+  if (!parsed_packet.Parse(packet, length))
+    return rtc::Optional<RtpPacketReceived>();
+
+  auto it = received_rtp_header_extensions_.find(parsed_packet.Ssrc());
+  if (it != received_rtp_header_extensions_.end()) {
+    // The existence of |it->second| is guaranteed during the lifetime of
+    // |parsed_packet|, due to us holding the |receive_crit_| lock in the

[brandtr, 2016/12/16 12:48:52]

Will update here when the RtpPacket CL has landed.

+    // DeliverRtp method.
+    parsed_packet.IdentifyExtensions(&it->second);
+  }
+
+  int64_t arrival_time_ms;
+  if (packet_time.timestamp != -1) {
+    arrival_time_ms = (packet_time.timestamp + 500) / 1000;
+  } else {
+    arrival_time_ms = clock_->TimeInMilliseconds();
+  }
+  parsed_packet.set_arrival_time_ms(arrival_time_ms);
+
+  return rtc::Optional<RtpPacketReceived>(std::move(parsed_packet));
+}
+
 void Call::UpdateHistograms() {
   RTC_HISTOGRAM_COUNTS_100000(
       "WebRTC.Call.LifetimeInSeconds",
       (clock_->TimeInMilliseconds() - start_ms_) / 1000);
 }
 
 void Call::UpdateSendHistograms() {
   if (first_packet_sent_ms_ == -1)
     return;
   int64_t elapsed_sec =
@@ skipping 294 matching lines @@
     ConfigureSync(receive_stream_impl->config().sync_group);
   }
   UpdateAggregateNetworkState();
   delete receive_stream_impl;
 }
 
 webrtc::FlexfecReceiveStream* Call::CreateFlexfecReceiveStream(
     const webrtc::FlexfecReceiveStream::Config& config) {
   TRACE_EVENT0("webrtc", "Call::CreateFlexfecReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
-  FlexfecReceiveStream* receive_stream = new FlexfecReceiveStream(config, this);
+
+  RecoveredPacketReceiver* recovered_packet_receiver = this;
+  FlexfecReceiveStream* receive_stream =
+      new FlexfecReceiveStream(config, recovered_packet_receiver);
 
   {
     WriteLockScoped write_lock(*receive_crit_);
+
+    RTC_DCHECK(flexfec_receive_streams_.find(receive_stream) ==
+               flexfec_receive_streams_.end());
+    flexfec_receive_streams_.insert(receive_stream);
+
     for (auto ssrc : config.protected_media_ssrcs)
       flexfec_receive_ssrcs_media_.insert(std::make_pair(ssrc, receive_stream));
+
     RTC_DCHECK(flexfec_receive_ssrcs_protection_.find(config.remote_ssrc) ==
                flexfec_receive_ssrcs_protection_.end());
     flexfec_receive_ssrcs_protection_[config.remote_ssrc] = receive_stream;
-    flexfec_receive_streams_.insert(receive_stream);
+
+    RTC_DCHECK(received_rtp_header_extensions_.find(config.remote_ssrc) ==
+               received_rtp_header_extensions_.end());
+    RtpHeaderExtensionMap rtp_header_extensions(config.rtp_header_extensions);
+    received_rtp_header_extensions_[config.remote_ssrc] = rtp_header_extensions;
   }
+
   // TODO(brandtr): Store config in RtcEventLog here.
+
   return receive_stream;
 }
 
 void Call::DestroyFlexfecReceiveStream(
     webrtc::FlexfecReceiveStream* receive_stream) {
   TRACE_EVENT0("webrtc", "Call::DestroyFlexfecReceiveStream");
   RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
+
   RTC_DCHECK(receive_stream != nullptr);
+
   // There exist no other derived classes of webrtc::FlexfecReceiveStream,
   // so this downcast is safe.
   FlexfecReceiveStream* receive_stream_impl =
       static_cast<FlexfecReceiveStream*>(receive_stream);
+
   {
     WriteLockScoped write_lock(*receive_crit_);
+
+    uint32_t ssrc = receive_stream_impl->GetConfig().remote_ssrc;
+    received_rtp_header_extensions_.erase(ssrc);
+
     // Remove all SSRCs pointing to the FlexfecReceiveStream to be destroyed.
-    auto media_it = flexfec_receive_ssrcs_media_.begin();
-    while (media_it != flexfec_receive_ssrcs_media_.end()) {
-      if (media_it->second == receive_stream_impl)
-        media_it = flexfec_receive_ssrcs_media_.erase(media_it);
-      else
-        ++media_it;
-    }
     auto prot_it = flexfec_receive_ssrcs_protection_.begin();
     while (prot_it != flexfec_receive_ssrcs_protection_.end()) {
       if (prot_it->second == receive_stream_impl)
         prot_it = flexfec_receive_ssrcs_protection_.erase(prot_it);
       else
         ++prot_it;
     }
+    auto media_it = flexfec_receive_ssrcs_media_.begin();
+    while (media_it != flexfec_receive_ssrcs_media_.end()) {
+      if (media_it->second == receive_stream_impl)
+        media_it = flexfec_receive_ssrcs_media_.erase(media_it);
+      else
+        ++media_it;
+    }
+
     flexfec_receive_streams_.erase(receive_stream_impl);
   }
+
   delete receive_stream_impl;
 }
 
 Call::Stats Call::GetStats() const {
   // TODO(solenberg): Some test cases in EndToEndTest use this from a different
   // thread. Re-enable once that is fixed.
   // RTC_DCHECK(configuration_thread_checker_.CalledOnValidThread());
   Stats stats;
   // Fetch available send/receive bitrates.
   uint32_t send_bandwidth = 0;
@@ skipping 353 matching lines @@
       if (status == DELIVERY_OK)
         event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
       return status;
     }
   }
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     auto it = video_receive_ssrcs_.find(ssrc);
     if (it != video_receive_ssrcs_.end()) {
       received_bytes_per_second_counter_.Add(static_cast<int>(length));
       received_video_bytes_per_second_counter_.Add(static_cast<int>(length));
+      // TODO(brandtr): Notify the BWE of received media packets here.
       auto status = it->second->DeliverRtp(packet, length, packet_time)
                         ? DELIVERY_OK
                         : DELIVERY_PACKET_ERROR;
-      // Deliver media packets to FlexFEC subsystem.
-      auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
-      for (auto it = it_bounds.first; it != it_bounds.second; ++it)
-        it->second->AddAndProcessReceivedPacket(packet, length);
+      // Deliver media packets to FlexFEC subsystem. RTP header extensions need
+      // not be parsed, as FlexFEC is oblivious to the semantic meaning of the
+      // packet contents beyond the 12 byte RTP base header. The BWE is fed
+      // information about these media packets from the regular media pipeline.
+      rtc::Optional<RtpPacketReceived> parsed_packet =
+          ParseRtpPacket(packet, length, packet_time);
+      if (parsed_packet) {
+        auto it_bounds = flexfec_receive_ssrcs_media_.equal_range(ssrc);
+        for (auto it = it_bounds.first; it != it_bounds.second; ++it)
+          it->second->AddAndProcessReceivedPacket(*parsed_packet);
+      }
       if (status == DELIVERY_OK)
         event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
       return status;
     }
   }
   if (media_type == MediaType::ANY || media_type == MediaType::VIDEO) {
     auto it = flexfec_receive_ssrcs_protection_.find(ssrc);
     if (it != flexfec_receive_ssrcs_protection_.end()) {
-      auto status = it->second->AddAndProcessReceivedPacket(packet, length)
-                        ? DELIVERY_OK
-                        : DELIVERY_PACKET_ERROR;
-      if (status == DELIVERY_OK)
-        event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
-      return status;
+      rtc::Optional<RtpPacketReceived> parsed_packet =
+          ParseRtpPacket(packet, length, packet_time);
+      if (parsed_packet) {
+        NotifyBweOfReceivedPacket(*parsed_packet);
+        auto status =
+            it->second->AddAndProcessReceivedPacket(std::move(*parsed_packet))
+                ? DELIVERY_OK
+                : DELIVERY_PACKET_ERROR;
+        if (status == DELIVERY_OK)
+          event_log_->LogRtpHeader(kIncomingPacket, media_type, packet, length);
+        return status;
+      }
     }
   }
   return DELIVERY_UNKNOWN_SSRC;
 }
 
 PacketReceiver::DeliveryStatus Call::DeliverPacket(
     MediaType media_type,
     const uint8_t* packet,
     size_t length,
     const PacketTime& packet_time) {
@@ skipping 11 matching lines @@
 // audio packets with FlexFEC.
 bool Call::OnRecoveredPacket(const uint8_t* packet, size_t length) {
   uint32_t ssrc = ByteReader<uint32_t>::ReadBigEndian(&packet[8]);
   ReadLockScoped read_lock(*receive_crit_);
   auto it = video_receive_ssrcs_.find(ssrc);
   if (it == video_receive_ssrcs_.end())
     return false;
   return it->second->OnRecoveredPacket(packet, length);
 }
 
+void Call::NotifyBweOfReceivedPacket(const RtpPacketReceived& packet) {

[stefan-webrtc, 2016/12/19 11:03:42]

Should we make this a method on CongestionController instead so that we can make
the RBE and the REP internal to the CongestionController later?

[brandtr, 2016/12/19 13:26:17]

Sounds good to me.

+  const bool transport_wide = packet.HasExtension<TransportSequenceNumber>();
+  const bool abs_send_time = packet.HasExtension<AbsoluteSendTime>();
+  const bool t_offset = packet.HasExtension<TransmissionOffset>();
+
+  // At least one of the header extensions is needed for the BWE.
+  if (!transport_wide && !abs_send_time && !t_offset)

[brandtr, 2016/12/19 13:26:17]

Is this too strict for the older BWEs?

(For send-side BWE, we should check that the transport_wide extension is set
before notifying the BWE. For the older BWEs, this is not always strictly
necessary.)

[stefan-webrtc, 2016/12/19 14:03:31]

Yes, too strict. The old BWE can take RTP timestamps without header extensions
at all.

[brandtr, 2016/12/19 14:26:53]

Done.

+    return;
+
+  RTPHeader header;
+  packet.GetHeader(&header);
+
+  // Send-side BWE.
+  if (remote_estimator_proxy_ && transport_wide) {
+    remote_estimator_proxy_->IncomingPacket(packet.arrival_time_ms(),
+                                            packet.payload_size(), header);
+    return;
+  }
+
+  // Receive-side BWE.
+  if (remote_bitrate_estimator_) {
+    remote_bitrate_estimator_->IncomingPacket(packet.arrival_time_ms(),
+                                              packet.payload_size(), header);
+  }
+}
+
 }  // namespace internal
 }  // namespace webrtc