1 files changed, 109 insertions, 11 deletions

diff --git a/modules/rtp_rtcp/source/rtcp_receiver.h b/modules/rtp_rtcp/source/rtcp_receiver.h
index 7b0f38bea0..57dd1c06b4 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver.h
+++ b/modules/rtp_rtcp/source/rtcp_receiver.h
@@ -15,21 +15,28 @@
 #include <map>
 #include <set>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 #include "api/array_view.h"
+#include "api/sequence_checker.h"
 #include "modules/rtp_rtcp/include/report_block_data.h"
 #include "modules/rtp_rtcp/include/rtcp_statistics.h"
 #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "modules/rtp_rtcp/source/rtcp_nack_stats.h"
 #include "modules/rtp_rtcp/source/rtcp_packet/dlrr.h"
+#include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
 #include "modules/rtp_rtcp/source/rtp_rtcp_interface.h"
 #include "rtc_base/synchronization/mutex.h"
+#include "rtc_base/system/no_unique_address.h"
 #include "rtc_base/thread_annotations.h"
 #include "system_wrappers/include/ntp_time.h"
 
 namespace webrtc {
+
+class ModuleRtpRtcpImpl2;
 class VideoBitrateAllocationObserver;
+
 namespace rtcp {
 class CommonHeader;
 class ReportBlock;
@@ -55,6 +62,10 @@ class RTCPReceiver final {
 
   RTCPReceiver(const RtpRtcpInterface::Configuration& config,
                ModuleRtpRtcp* owner);
+
+  RTCPReceiver(const RtpRtcpInterface::Configuration& config,
+               ModuleRtpRtcpImpl2* owner);
+
   ~RTCPReceiver();
 
   void IncomingPacket(const uint8_t* packet, size_t packet_size) {
@@ -64,9 +75,14 @@ class RTCPReceiver final {
 
   int64_t LastReceivedReportBlockMs() const;
 
+  void set_local_media_ssrc(uint32_t ssrc);
+  uint32_t local_media_ssrc() const;
+
   void SetRemoteSSRC(uint32_t ssrc);
   uint32_t RemoteSSRC() const;
 
+  bool receiver_only() const { return receiver_only_; }
+
   // Get received NTP.
   // The types for the arguments below derive from the specification:
   // - `remote_sender_packet_count`: `RTCSentRtpStreamStats.packetsSent` [1]
@@ -124,10 +140,95 @@ class RTCPReceiver final {
   void NotifyTmmbrUpdated();
 
  private:
+#if RTC_DCHECK_IS_ON
+  class CustomSequenceChecker : public SequenceChecker {
+   public:
+    explicit CustomSequenceChecker(bool disable_checks)
+        : disable_checks_(disable_checks) {}
+    bool IsCurrent() const {
+      if (disable_checks_)
+        return true;
+      return SequenceChecker::IsCurrent();
+    }
+
+   private:
+    const bool disable_checks_;
+  };
+#else
+  class CustomSequenceChecker : public SequenceChecker {
+   public:
+    explicit CustomSequenceChecker(bool) {}
+  };
+#endif
+
+  // A lightweight inlined set of local SSRCs.
+  class RegisteredSsrcs {
+   public:
+    static constexpr size_t kMediaSsrcIndex = 0;
+    static constexpr size_t kMaxSsrcs = 3;
+    // Initializes the set of registered local SSRCS by extracting them from the
+    // provided `config`. The `disable_sequence_checker` flag is a workaround
+    // to be able to use a sequence checker without breaking downstream
+    // code that currently doesn't follow the same threading rules as webrtc.
+    RegisteredSsrcs(bool disable_sequence_checker,
+                    const RtpRtcpInterface::Configuration& config);
+
+    // Indicates if `ssrc` is in the set of registered local SSRCs.
+    bool contains(uint32_t ssrc) const;
+    uint32_t media_ssrc() const;
+    void set_media_ssrc(uint32_t ssrc);
+
+   private:
+    RTC_NO_UNIQUE_ADDRESS CustomSequenceChecker packet_sequence_checker_;
+    absl::InlinedVector<uint32_t, kMaxSsrcs> ssrcs_
+        RTC_GUARDED_BY(packet_sequence_checker_);
+  };
+
   struct PacketInformation;
-  struct TmmbrInformation;
-  struct RrtrInformation;
-  struct LastFirStatus;
+
+  // Structure for handing TMMBR and TMMBN rtcp messages (RFC5104,
+  // section 3.5.4).
+  struct TmmbrInformation {
+    struct TimedTmmbrItem {
+      rtcp::TmmbItem tmmbr_item;
+      int64_t last_updated_ms;
+    };
+
+    int64_t last_time_received_ms = 0;
+
+    bool ready_for_delete = false;
+
+    std::vector<rtcp::TmmbItem> tmmbn;
+    std::map<uint32_t, TimedTmmbrItem> tmmbr;
+  };
+
+  // Structure for storing received RRTR RTCP messages (RFC3611, section 4.4).
+  struct RrtrInformation {
+    RrtrInformation(uint32_t ssrc,
+                    uint32_t received_remote_mid_ntp_time,
+                    uint32_t local_receive_mid_ntp_time)
+        : ssrc(ssrc),
+          received_remote_mid_ntp_time(received_remote_mid_ntp_time),
+          local_receive_mid_ntp_time(local_receive_mid_ntp_time) {}
+
+    uint32_t ssrc;
+    // Received NTP timestamp in compact representation.
+    uint32_t received_remote_mid_ntp_time;
+    // NTP time when the report was received in compact representation.
+    uint32_t local_receive_mid_ntp_time;
+  };
+
+  struct LastFirStatus {
+    LastFirStatus(int64_t now_ms, uint8_t sequence_number)
+        : request_ms(now_ms), sequence_number(sequence_number) {}
+    int64_t request_ms;
+    uint8_t sequence_number;
+  };
+
+  // TODO(boivie): `ReportBlockDataMap` and `ReportBlockMap` should be converted
+  // to std::unordered_map, but as there are too many tests that assume a
+  // specific order, it's not easily done.
+
   // RTCP report blocks mapped by remote SSRC.
   using ReportBlockDataMap = std::map<uint32_t, ReportBlockData>;
   // RTCP report blocks map mapped by source SSRC.
@@ -229,7 +330,8 @@ class RTCPReceiver final {
   const bool receiver_only_;
   ModuleRtpRtcp* const rtp_rtcp_;
   const uint32_t main_ssrc_;
-  const std::set<uint32_t> registered_ssrcs_;
+  // The set of registered local SSRCs.
+  RegisteredSsrcs registered_ssrcs_;
 
   RtcpBandwidthObserver* const rtcp_bandwidth_observer_;
   RtcpIntraFrameObserver* const rtcp_intra_frame_observer_;
@@ -255,7 +357,7 @@ class RTCPReceiver final {
   std::list<RrtrInformation> received_rrtrs_
       RTC_GUARDED_BY(rtcp_receiver_lock_);
   // Received RRTR information mapped by remote ssrc.
-  std::map<uint32_t, std::list<RrtrInformation>::iterator>
+  std::unordered_map<uint32_t, std::list<RrtrInformation>::iterator>
       received_rrtrs_ssrc_it_ RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // Estimated rtt, zero when there is no valid estimate.
@@ -264,11 +366,11 @@ class RTCPReceiver final {
 
   int64_t oldest_tmmbr_info_ms_ RTC_GUARDED_BY(rtcp_receiver_lock_);
   // Mapped by remote ssrc.
-  std::map<uint32_t, TmmbrInformation> tmmbr_infos_
+  std::unordered_map<uint32_t, TmmbrInformation> tmmbr_infos_
       RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   ReportBlockMap received_report_blocks_ RTC_GUARDED_BY(rtcp_receiver_lock_);
-  std::map<uint32_t, LastFirStatus> last_fir_
+  std::unordered_map<uint32_t, LastFirStatus> last_fir_
       RTC_GUARDED_BY(rtcp_receiver_lock_);
 
   // The last time we received an RTCP Report block for this module.
@@ -279,11 +381,7 @@ class RTCPReceiver final {
   // delivered RTP packet to the remote side.
   Timestamp last_increased_sequence_number_ = Timestamp::PlusInfinity();
 
-  RtcpStatisticsCallback* const stats_callback_;
   RtcpCnameCallback* const cname_callback_;
-  // TODO(hbos): Remove RtcpStatisticsCallback in favor of
-  // ReportBlockDataObserver; the ReportBlockData contains a superset of the
-  // RtcpStatistics data.
   ReportBlockDataObserver* const report_block_data_observer_;
 
   RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;