[feat] use original webrtc header defines

src/rtp/rtp_packet/rtp_header.h

@@ -0,0 +1,44 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2025-01-16
+ * Copyright (c) 2025 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _RTP_HEADER_H_
+#define _RTP_HEADER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <string>
+
+#include "api/units/timestamp.h"
+
+enum { kRtpCsrcSize = 15 };  // RFC 3550 page 13
+
+struct RTPHeader {
+  RTPHeader()
+      : markerBit(false),
+        payloadType(0),
+        sequenceNumber(0),
+        timestamp(0),
+        ssrc(0),
+        numCSRCs(0),
+        arrOfCSRCs(),
+        paddingLength(0),
+        headerLength(0){};
+  RTPHeader(const RTPHeader& other) = default;
+  RTPHeader& operator=(const RTPHeader& other) = default;
+
+  bool markerBit;
+  uint8_t payloadType;
+  uint16_t sequenceNumber;
+  uint32_t timestamp;
+  uint32_t ssrc;
+  uint8_t numCSRCs;
+  uint32_t arrOfCSRCs[kRtpCsrcSize];
+  size_t paddingLength;
+  size_t headerLength;
+};
+
+#endif

src/rtp/rtp_packet/rtp_packet.cpp

@@ -35,6 +35,7 @@ void RtpPacket::ParseRtpData() {
 
 RtpPacket::RtpPacket() : buffer_(new uint8_t[DEFAULT_MTU]), size_(DEFAULT_MTU) {
   memset(buffer_, 0, DEFAULT_MTU);
+  ParseRtpData();
 }
 
 RtpPacket::RtpPacket(const uint8_t *buffer, uint32_t size) {
@@ -48,6 +49,7 @@ RtpPacket::RtpPacket(const uint8_t *buffer, uint32_t size) {
     size_ = size;
 
     // TryToDecodeH264RtpPacket(buffer_);
+    ParseRtpData();
   }
 }
 
@@ -62,6 +64,7 @@ RtpPacket::RtpPacket(const RtpPacket &rtp_packet) {
     size_ = rtp_packet.size_;
 
     // TryToDecodeH264RtpPacket(buffer_);
+    ParseRtpData();
   }
 }
 
@@ -72,6 +75,7 @@ RtpPacket::RtpPacket(RtpPacket &&rtp_packet)
   rtp_packet.size_ = 0;
 
   // TryToDecodeH264RtpPacket(buffer_);
+  ParseRtpData();
 }
 
 // RtpPacket &RtpPacket::operator=(const RtpPacket &rtp_packet) {

src/rtp/rtp_packet/rtp_packet.h

@@ -278,48 +278,48 @@ class RtpPacket {
 
  public:
   // Get Header
-  uint32_t Verion() {
-    ParseRtpData();
+  uint32_t Verion() const {
+    // // ParseRtpData();
     return version_;
   }
-  bool HasPadding() {
-    ParseRtpData();
+  bool HasPadding() const {
+    // ParseRtpData();
     return has_padding_;
   }
-  bool HasExtension() {
-    ParseRtpData();
+  bool HasExtension() const {
+    // ParseRtpData();
     return has_extension_;
   }
-  bool Marker() {
-    ParseRtpData();
+  bool Marker() const {
+    // // ParseRtpData();
     return marker_;
   }
-  PAYLOAD_TYPE PayloadType() {
-    ParseRtpData();
+  PAYLOAD_TYPE PayloadType() const {
+    // ParseRtpData();
     return PAYLOAD_TYPE(payload_type_);
   }
-  uint16_t SequenceNumber() {
-    ParseRtpData();
+  uint16_t SequenceNumber() const {
+    // ParseRtpData();
     return sequence_number_;
   }
-  uint64_t Timestamp() {
-    ParseRtpData();
+  uint64_t Timestamp() const {
+    // ParseRtpData();
     return timestamp_;
   }
-  uint32_t Ssrc() {
-    ParseRtpData();
+  uint32_t Ssrc() const {
+    // ParseRtpData();
     return ssrc_;
   }
-  std::vector<uint32_t> Csrcs() {
-    ParseRtpData();
+  std::vector<uint32_t> Csrcs() const {
+    // ParseRtpData();
     return csrcs_;
   };
-  uint16_t ExtensionProfile() {
-    ParseRtpData();
+  uint16_t ExtensionProfile() const {
+    // ParseRtpData();
     return extension_profile_;
   }
   const uint8_t *ExtensionData() {
-    ParseRtpData();
+    // ParseRtpData();
     return extension_data_;
   }
 
@@ -336,34 +336,42 @@ class RtpPacket {
 
   // Payload
   const uint8_t *Payload() {
-    ParseRtpData();
+    // ParseRtpData();
     return payload_;
   };
   size_t PayloadSize() {
-    ParseRtpData();
+    // ParseRtpData();
     return payload_size_;
   }
 
+  size_t headers_size() const { return 12; }
+
+  size_t payload_size() const { return payload_size_; }
+
+  bool has_padding() const { return buffer_[0] & 0x20; }
+
+  size_t padding_size() const { return padding_size_; }
+
   // Entire RTP buffer
   const uint8_t *Buffer() const { return buffer_; }
   size_t Size() const { return size_; }
 
   // NAL
   NAL_UNIT_TYPE NalUnitType() {
-    ParseRtpData();
+    // ParseRtpData();
     return nal_unit_type_;
   }
   bool FuAStart() {
-    ParseRtpData();
+    // ParseRtpData();
     return fu_header_.start;
   }
   bool FuAEnd() {
-    ParseRtpData();
+    // ParseRtpData();
     return fu_header_.end;
   }
 
   bool Av1FrameStart() {
-    ParseRtpData();
+    // ParseRtpData();
     int z, y, w, n;
     GetAv1AggrHeader(z, y, w, n);
     // return !z && !y;
@@ -378,7 +386,7 @@ class RtpPacket {
   }
 
   bool Av1FrameEnd() {
-    ParseRtpData();
+    // ParseRtpData();
     int z, y, w, n;
     GetAv1AggrHeader(z, y, w, n);
     // return z && !y;
@@ -421,6 +429,7 @@ class RtpPacket {
   // Payload
   uint8_t *payload_ = nullptr;
   size_t payload_size_ = 0;
+  size_t padding_size_ = 0;
 
   // Entire RTP buffer
   uint8_t *buffer_ = nullptr;

src/rtp/rtp_packet/rtp_packet_received.cpp

@@ -1,6 +1,28 @@
+/*
+ *  Copyright (c) 2017 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 "rtp_packet_received.h"
 
+#include <stddef.h>
+
+#include <cstdint>
+#include <vector>
+
+#include "rtc_base/numerics/safe_conversions.h"
+
+namespace webrtc {
+
 RtpPacketReceived::RtpPacketReceived() = default;
+RtpPacketReceived::RtpPacketReceived(
+    webrtc::Timestamp arrival_time /*= webrtc::Timestamp::MinusInfinity()*/)
+    : RtpPacket(), arrival_time_(arrival_time) {}
 RtpPacketReceived::RtpPacketReceived(const RtpPacketReceived& packet) = default;
 RtpPacketReceived::RtpPacketReceived(RtpPacketReceived&& packet) = default;
 
@@ -10,3 +32,20 @@ RtpPacketReceived& RtpPacketReceived::operator=(RtpPacketReceived&& packet) =
     default;
 
 RtpPacketReceived::~RtpPacketReceived() {}
+
+void RtpPacketReceived::GetHeader(RTPHeader* header) const {
+  header->markerBit = Marker();
+  header->payloadType = PayloadType();
+  header->sequenceNumber = SequenceNumber();
+  header->timestamp = Timestamp();
+  header->ssrc = Ssrc();
+  std::vector<uint32_t> csrcs = Csrcs();
+  header->numCSRCs = rtc::dchecked_cast<uint8_t>(csrcs.size());
+  for (size_t i = 0; i < csrcs.size(); ++i) {
+    header->arrOfCSRCs[i] = csrcs[i];
+  }
+  header->paddingLength = padding_size();
+  header->headerLength = headers_size();
+}
+
+}  // namespace webrtc

src/rtp/rtp_packet/rtp_packet_received.h

@@ -1,20 +1,36 @@
 /*
- * @Author: DI JUNKUN
- * @Date: 2024-12-18
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
+ *  Copyright (c) 2016 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.
  */
+#ifndef MODULES_RTP_RTCP_SOURCE_RTP_PACKET_RECEIVED_H_
+#define MODULES_RTP_RTCP_SOURCE_RTP_PACKET_RECEIVED_H_
 
-#ifndef _RTP_PACKET_RECEIVED_H_
-#define _RTP_PACKET_RECEIVED_H_
+#include <stdint.h>
 
-#include <limits>
+#include <utility>
 
-#include "enc_mark.h"
+#include "api/array_view.h"
+#include "api/ref_counted_base.h"
+#include "api/scoped_refptr.h"
+#include "api/units/timestamp.h"
+#include "rtc_base/network/ecn_marking.h"
+#include "rtp_header.h"
 #include "rtp_packet.h"
 
+namespace webrtc {
+// Class to hold rtp packet with metadata for receiver side.
+// The metadata is not parsed from the rtp packet, but may be derived from the
+// data that is parsed from the rtp packet.
 class RtpPacketReceived : public RtpPacket {
  public:
   RtpPacketReceived();
+  explicit RtpPacketReceived(
+      webrtc::Timestamp arrival_time = webrtc::Timestamp::MinusInfinity());
   RtpPacketReceived(const RtpPacketReceived& packet);
   RtpPacketReceived(RtpPacketReceived&& packet);
 
@@ -23,14 +39,19 @@ class RtpPacketReceived : public RtpPacket {
 
   ~RtpPacketReceived();
 
- public:
-  int64_t arrival_time() const { return arrival_time_; }
-  void set_arrival_time(int64_t time) { arrival_time_ = time; }
+  // TODO(bugs.webrtc.org/15054): Remove this function when all code is updated
+  // to use RtpPacket directly.
+  void GetHeader(RTPHeader* header) const;
+
+  // Time in local time base as close as it can to packet arrived on the
+  // network.
+  webrtc::Timestamp arrival_time() const { return arrival_time_; }
+  void set_arrival_time(webrtc::Timestamp time) { arrival_time_ = time; }
 
   // Explicit Congestion Notification (ECN), RFC-3168, Section 5.
   // Used by L4S: https://www.rfc-editor.org/rfc/rfc9331.html
-  EcnMarking ecn() const { return ecn_; }
-  void set_ecn(EcnMarking ecn) { ecn_ = ecn; }
+  rtc::EcnMarking ecn() const { return ecn_; }
+  void set_ecn(rtc::EcnMarking ecn) { ecn_ = ecn; }
 
   // Flag if packet was recovered via RTX or FEC.
   bool recovered() const { return recovered_; }
@@ -41,11 +62,22 @@ class RtpPacketReceived : public RtpPacket {
     payload_type_frequency_ = value;
   }
 
+  // An application can attach arbitrary data to an RTP packet using
+  // `additional_data`. The additional data does not affect WebRTC processing.
+  rtc::scoped_refptr<rtc::RefCountedBase> additional_data() const {
+    return additional_data_;
+  }
+  void set_additional_data(rtc::scoped_refptr<rtc::RefCountedBase> data) {
+    additional_data_ = std::move(data);
+  }
+
  private:
-  int64_t arrival_time_ = std::numeric_limits<int64_t>::min();
-  EcnMarking ecn_ = EcnMarking::kNotEct;
+  webrtc::Timestamp arrival_time_ = Timestamp::MinusInfinity();
+  rtc::EcnMarking ecn_ = rtc::EcnMarking::kNotEct;
   int payload_type_frequency_ = 0;
   bool recovered_ = false;
+  rtc::scoped_refptr<rtc::RefCountedBase> additional_data_;
 };
 
-#endif
+}  // namespace webrtc
+#endif  // MODULES_RTP_RTCP_SOURCE_RTP_PACKET_RECEIVED_H_