Encapsulate and make RTP sequence number available in RtpPacketInfo.

Bug: b/462514208
Change-Id: I63f9235253f229a8059f752d6186409fc1eb24f2
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/452722
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Reviewed-by: Per Kjellander <perkj@webrtc.org>
Commit-Queue: Per Kjellander <perkj@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#47128}
diff --git a/api/BUILD.gn b/api/BUILD.gn
index fea2f3e..8c62fe2 100644
--- a/api/BUILD.gn
+++ b/api/BUILD.gn
@@ -145,6 +145,7 @@
     ":refcountedbase",
     ":rtp_headers",
     ":scoped_refptr",
+    "../modules/rtp_rtcp:rtp_rtcp_format",
     "../rtc_base/system:rtc_export",
     "units:time_delta",
     "units:timestamp",
@@ -1871,6 +1872,7 @@
       "../media:media_constants",
       "../media:rid_description",
       "../media:stream_params",
+      "../modules/rtp_rtcp:rtp_rtcp_format",
       "../p2p:p2p_constants",
       "../p2p:transport_description",
       "../p2p:transport_info",
diff --git a/api/rtp_packet_info.cc b/api/rtp_packet_info.cc
index 557247b..6bbb135 100644
--- a/api/rtp_packet_info.cc
+++ b/api/rtp_packet_info.cc
@@ -18,24 +18,48 @@
 
 #include "api/rtp_headers.h"
 #include "api/units/timestamp.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
 
 namespace webrtc {
 
 RtpPacketInfo::RtpPacketInfo()
-    : ssrc_(0), rtp_timestamp_(0), receive_time_(Timestamp::MinusInfinity()) {}
+    : sequence_number_(0),
+      ssrc_(0),
+      rtp_timestamp_(0),
+      receive_time_(Timestamp::MinusInfinity()) {}
+
+RtpPacketInfo::RtpPacketInfo(const RtpPacketReceived& rtp_packet)
+    : sequence_number_(rtp_packet.SequenceNumber()),
+      ssrc_(rtp_packet.Ssrc()),
+      csrcs_(rtp_packet.Csrcs()),
+      rtp_timestamp_(rtp_packet.Timestamp()),
+      receive_time_(rtp_packet.arrival_time()) {
+  AudioLevel audio_level;
+  if (rtp_packet.GetExtension<AudioLevelExtension>(&audio_level)) {
+    audio_level_ = audio_level.level();
+  }
+
+  AbsoluteCaptureTime capture_time;
+  if (rtp_packet.GetExtension<AbsoluteCaptureTimeExtension>(&capture_time)) {
+    absolute_capture_time_ = std::move(capture_time);
+  }
+}
 
 RtpPacketInfo::RtpPacketInfo(uint32_t ssrc,
                              std::vector<uint32_t> csrcs,
                              uint32_t rtp_timestamp,
                              Timestamp receive_time)
-    : ssrc_(ssrc),
+    : sequence_number_(0),
+      ssrc_(ssrc),
       csrcs_(std::move(csrcs)),
       rtp_timestamp_(rtp_timestamp),
       receive_time_(receive_time) {}
 
 RtpPacketInfo::RtpPacketInfo(const RTPHeader& rtp_header,
                              Timestamp receive_time)
-    : ssrc_(rtp_header.ssrc),
+    : sequence_number_(rtp_header.sequenceNumber),
+      ssrc_(rtp_header.ssrc),
       rtp_timestamp_(rtp_header.timestamp),
       receive_time_(receive_time) {
   const auto& extension = rtp_header.extension;
@@ -50,13 +74,6 @@
   absolute_capture_time_ = extension.absolute_capture_time;
 }
 
-bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs) {
-  return (lhs.ssrc() == rhs.ssrc()) && (lhs.csrcs() == rhs.csrcs()) &&
-         (lhs.rtp_timestamp() == rhs.rtp_timestamp()) &&
-         (lhs.receive_time() == rhs.receive_time()) &&
-         (lhs.audio_level() == rhs.audio_level()) &&
-         (lhs.absolute_capture_time() == rhs.absolute_capture_time()) &&
-         (lhs.local_capture_clock_offset() == rhs.local_capture_clock_offset());
-}
+bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs) = default;
 
 }  // namespace webrtc
diff --git a/api/rtp_packet_info.h b/api/rtp_packet_info.h
index 4059108..943975b 100644
--- a/api/rtp_packet_info.h
+++ b/api/rtp_packet_info.h
@@ -23,6 +23,8 @@
 
 namespace webrtc {
 
+class RtpPacketReceived;
+
 //
 // Structure to hold information about a received `RtpPacket`. It is primarily
 // used to carry per-packet information from when a packet is received until
@@ -32,11 +34,17 @@
  public:
   RtpPacketInfo();
 
+  explicit RtpPacketInfo(const RtpPacketReceived& rtp_packet);
+
+  // TODO: bugs.webrtc.org/42225366 - The constructor will be deprecated. Use
+  // RtpPacketInfo(const RtpPacketReceived& rtp_packet).
   RtpPacketInfo(uint32_t ssrc,
                 std::vector<uint32_t> csrcs,
                 uint32_t rtp_timestamp,
                 Timestamp receive_time);
 
+  // TODO: bugs.webrtc.org/42225366 - The constructor will be deprecated. Use
+  // RtpPacketInfo(const RtpPacketReceived& rtp_packet).
   RtpPacketInfo(const RTPHeader& rtp_header, Timestamp receive_time);
 
   RtpPacketInfo(const RtpPacketInfo& other) = default;
@@ -47,6 +55,9 @@
   uint32_t ssrc() const { return ssrc_; }
   void set_ssrc(uint32_t value) { ssrc_ = value; }
 
+  uint16_t sequence_number() const { return sequence_number_; }
+  void set_sequence_number(uint16_t value) { sequence_number_ = value; }
+
   const std::vector<uint32_t>& csrcs() const { return csrcs_; }
   void set_csrcs(std::vector<uint32_t> value) { csrcs_ = std::move(value); }
 
@@ -80,9 +91,12 @@
     return *this;
   }
 
+  friend bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs);
+
  private:
   // Fields from the RTP header:
   // https://tools.ietf.org/html/rfc3550#section-5.1
+  uint16_t sequence_number_;
   uint32_t ssrc_;
   std::vector<uint32_t> csrcs_;
   uint32_t rtp_timestamp_;
@@ -106,12 +120,6 @@
   std::optional<TimeDelta> local_capture_clock_offset_;
 };
 
-bool operator==(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs);
-
-inline bool operator!=(const RtpPacketInfo& lhs, const RtpPacketInfo& rhs) {
-  return !(lhs == rhs);
-}
-
 }  // namespace webrtc
 
 #endif  // API_RTP_PACKET_INFO_H_
diff --git a/api/rtp_packet_info_unittest.cc b/api/rtp_packet_info_unittest.cc
index 9aea11d..c61d1bd 100644
--- a/api/rtp_packet_info_unittest.cc
+++ b/api/rtp_packet_info_unittest.cc
@@ -17,9 +17,29 @@
 #include "api/rtp_headers.h"
 #include "api/units/time_delta.h"
 #include "api/units/timestamp.h"
+#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
+#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
+#include "modules/rtp_rtcp/source/rtp_packet_received.h"
+#include "rtc_base/checks.h"
+#include "test/gmock.h"
 #include "test/gtest.h"
 
 namespace webrtc {
+namespace {
+
+using ::testing::ElementsAreArray;
+using ::testing::Optional;
+
+template <typename ExtensionType,
+          typename ExtensionValue = ExtensionType::value_type>
+RtpPacketReceived CreateRtpPacketReceivedWithExtension(ExtensionValue value) {
+  RtpHeaderExtensionMap extensions;
+  extensions.Register<ExtensionType>(5);
+  RtpPacketReceived packet(&extensions);
+  RTC_CHECK(packet.SetExtension<ExtensionType>(value))
+      << "Unable to set extension.";
+  return packet;
+}
 
 TEST(RtpPacketInfoTest, Ssrc) {
   constexpr uint32_t kValue = 4038189233;
@@ -44,13 +64,12 @@
   rhs = RtpPacketInfo();
   EXPECT_NE(rhs.ssrc(), kValue);
 
-  rhs = RtpPacketInfo(/*ssrc=*/kValue, /*csrcs=*/{}, /*rtp_timestamp=*/{},
-                      /*receive_time=*/Timestamp::Zero());
+  rhs.set_ssrc(kValue);
   EXPECT_EQ(rhs.ssrc(), kValue);
 }
 
-TEST(RtpPacketInfoTest, Csrcs) {
-  const std::vector<uint32_t> value = {4038189233, 3016333617, 1207992985};
+TEST(RtpPacketInfoTest, SequenceNumber) {
+  constexpr uint16_t kValue = 34653;
 
   RtpPacketInfo lhs;
   RtpPacketInfo rhs;
@@ -58,8 +77,8 @@
   EXPECT_TRUE(lhs == rhs);
   EXPECT_FALSE(lhs != rhs);
 
-  rhs.set_csrcs(value);
-  EXPECT_EQ(rhs.csrcs(), value);
+  rhs.set_sequence_number(kValue);
+  EXPECT_EQ(rhs.sequence_number(), kValue);
 
   EXPECT_FALSE(lhs == rhs);
   EXPECT_TRUE(lhs != rhs);
@@ -70,11 +89,37 @@
   EXPECT_FALSE(lhs != rhs);
 
   rhs = RtpPacketInfo();
-  EXPECT_NE(rhs.csrcs(), value);
+  EXPECT_NE(rhs.sequence_number(), kValue);
 
-  rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/value, /*rtp_timestamp=*/{},
-                      /*receive_time=*/Timestamp::Zero());
-  EXPECT_EQ(rhs.csrcs(), value);
+  rhs.set_sequence_number(kValue);
+  EXPECT_EQ(rhs.sequence_number(), kValue);
+}
+
+TEST(RtpPacketInfoTest, Csrcs) {
+  const std::vector<uint32_t> kValue = {4038189233, 3016333617, 1207992985};
+
+  RtpPacketInfo lhs;
+  RtpPacketInfo rhs;
+
+  EXPECT_TRUE(lhs == rhs);
+  EXPECT_FALSE(lhs != rhs);
+
+  rhs.set_csrcs(kValue);
+  EXPECT_EQ(rhs.csrcs(), kValue);
+
+  EXPECT_FALSE(lhs == rhs);
+  EXPECT_TRUE(lhs != rhs);
+
+  lhs = rhs;
+
+  EXPECT_TRUE(lhs == rhs);
+  EXPECT_FALSE(lhs != rhs);
+
+  rhs = RtpPacketInfo();
+  EXPECT_NE(rhs.csrcs(), kValue);
+
+  rhs.set_csrcs(kValue);
+  EXPECT_EQ(rhs.csrcs(), kValue);
 }
 
 TEST(RtpPacketInfoTest, RtpTimestamp) {
@@ -100,8 +145,7 @@
   rhs = RtpPacketInfo();
   EXPECT_NE(rhs.rtp_timestamp(), kValue);
 
-  rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/kValue,
-                      /*receive_time=*/Timestamp::Zero());
+  rhs.set_rtp_timestamp(kValue);
   EXPECT_EQ(rhs.rtp_timestamp(), kValue);
 }
 
@@ -128,8 +172,7 @@
   rhs = RtpPacketInfo();
   EXPECT_NE(rhs.receive_time(), kValue);
 
-  rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
-                      /*receive_time=*/kValue);
+  rhs.set_receive_time(kValue);
   EXPECT_EQ(rhs.receive_time(), kValue);
 }
 
@@ -156,8 +199,6 @@
   rhs = RtpPacketInfo();
   EXPECT_NE(rhs.audio_level(), kValue);
 
-  rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
-                      /*receive_time=*/Timestamp::Zero());
   rhs.set_audio_level(kValue);
   EXPECT_EQ(rhs.audio_level(), kValue);
 }
@@ -186,8 +227,6 @@
   rhs = RtpPacketInfo();
   EXPECT_NE(rhs.absolute_capture_time(), kValue);
 
-  rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
-                      /*receive_time=*/Timestamp::Zero());
   rhs.set_absolute_capture_time(kValue);
   EXPECT_EQ(rhs.absolute_capture_time(), kValue);
 }
@@ -215,10 +254,52 @@
   rhs = RtpPacketInfo();
   EXPECT_EQ(rhs.local_capture_clock_offset(), std::nullopt);
 
-  rhs = RtpPacketInfo(/*ssrc=*/{}, /*csrcs=*/{}, /*rtp_timestamp=*/{},
-                      /*receive_time=*/Timestamp::Zero());
   rhs.set_local_capture_clock_offset(kValue);
   EXPECT_EQ(rhs.local_capture_clock_offset(), kValue);
 }
 
+TEST(RtpPacketInfoTest, RtpPacketReceivedNoExtensions) {
+  constexpr Timestamp kArrivalTime = Timestamp::Micros(8868963877546349045LL);
+  constexpr uint32_t kSsrc = 4038189233;
+  constexpr uint16_t kSequenceNumber = 1234;
+  constexpr uint32_t kRtpTimestamp = 5684353;
+  const std::vector<uint32_t> kCsrcs = {15, 60};
+  RtpPacketReceived packet;
+  packet.set_arrival_time(kArrivalTime);
+  packet.SetSsrc(kSsrc);
+  packet.SetCsrcs(kCsrcs);
+  packet.SetSequenceNumber(kSequenceNumber);
+  packet.SetTimestamp(kRtpTimestamp);
+
+  RtpPacketInfo rtp_packet_info(packet);
+
+  EXPECT_EQ(rtp_packet_info.ssrc(), kSsrc);
+  EXPECT_EQ(rtp_packet_info.sequence_number(), kSequenceNumber);
+  EXPECT_THAT(rtp_packet_info.csrcs(), ElementsAreArray(kCsrcs));
+  EXPECT_EQ(rtp_packet_info.rtp_timestamp(), kRtpTimestamp);
+  EXPECT_EQ(rtp_packet_info.receive_time(), kArrivalTime);
+}
+
+TEST(RtpPacketInfoTest, RtpPacketReceivedAudioLevel) {
+  constexpr uint8_t kValue = 14;
+  RtpPacketReceived packet =
+      CreateRtpPacketReceivedWithExtension<AudioLevelExtension>(
+          AudioLevel(/*voice_activity=*/true, /*level=*/kValue));
+
+  EXPECT_THAT(RtpPacketInfo(packet).audio_level(), Optional(kValue));
+}
+
+TEST(RtpPacketInfoTest, RtpPacketReceivedAbsoluteCaptureTime) {
+  const AbsoluteCaptureTime kAbsoluteCaptureTime = {
+      .absolute_capture_timestamp = 1493489345934859334,
+      .estimated_capture_clock_offset = 3453534534};
+  RtpPacketReceived packet =
+      CreateRtpPacketReceivedWithExtension<AbsoluteCaptureTimeExtension>(
+          kAbsoluteCaptureTime);
+
+  EXPECT_THAT(RtpPacketInfo(packet).absolute_capture_time(),
+              Optional(kAbsoluteCaptureTime));
+}
+
+}  // namespace
 }  // namespace webrtc