[feat] add rtcp packet module

src/common/sequence_number_compare.h

@@ -0,0 +1,44 @@
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+
+template <typename U>
+inline bool IsNewer(U value, U prev_value) {
+  static_assert(!std::numeric_limits<U>::is_signed, "U must be unsigned");
+  // kBreakpoint is the half-way mark for the type U. For instance, for a
+  // uint16_t it will be 0x8000, and for a uint32_t, it will be 0x8000000.
+  constexpr U kBreakpoint = (std::numeric_limits<U>::max() >> 1) + 1;
+  // Distinguish between elements that are exactly kBreakpoint apart.
+  // If t1>t2 and |t1-t2| = kBreakpoint: IsNewer(t1,t2)=true,
+  // IsNewer(t2,t1)=false
+  // rather than having IsNewer(t1,t2) = IsNewer(t2,t1) = false.
+  if (value - prev_value == kBreakpoint) {
+    return value > prev_value;
+  }
+  return value != prev_value &&
+         static_cast<U>(value - prev_value) < kBreakpoint;
+}
+
+// NB: Doesn't fulfill strict weak ordering requirements.
+//     Mustn't be used as std::map Compare function.
+inline bool IsNewerSequenceNumber(uint16_t sequence_number,
+                                  uint16_t prev_sequence_number) {
+  return IsNewer(sequence_number, prev_sequence_number);
+}
+
+// NB: Doesn't fulfill strict weak ordering requirements.
+//     Mustn't be used as std::map Compare function.
+inline bool IsNewerTimestamp(uint32_t timestamp, uint32_t prev_timestamp) {
+  return IsNewer(timestamp, prev_timestamp);
+}
+
+inline uint16_t LatestSequenceNumber(uint16_t sequence_number1,
+                                     uint16_t sequence_number2) {
+  return IsNewerSequenceNumber(sequence_number1, sequence_number2)
+             ? sequence_number1
+             : sequence_number2;
+}
+
+inline uint32_t LatestTimestamp(uint32_t timestamp1, uint32_t timestamp2) {
+  return IsNewerTimestamp(timestamp1, timestamp2) ? timestamp1 : timestamp2;
+}

src/common/sequence_number_unwrapper.h

@@ -1,70 +0,0 @@
-/*
- * @Author: DI JUNKUN
- * @Date: 2024-08-21
- * Copyright (c) 2024 by DI JUNKUN, All Rights Reserved.
- */
-
-#ifndef _SEQUENCE_NUMBER_UNWRAPPER_H_
-#define _SEQUENCE_NUMBER_UNWRAPPER_H_
-
-#include <stdint.h>
-
-#include <limits>
-#include <type_traits>
-
-// A sequence number unwrapper where the first unwrapped value equals the
-// first value being unwrapped.
-template <typename T, T M = 0>
-class SeqNumUnwrapper {
-  static_assert(
-      std::is_unsigned<T>::value &&
-          std::numeric_limits<T>::max() < std::numeric_limits<int64_t>::max(),
-      "Type unwrapped must be an unsigned integer smaller than int64_t.");
-
- public:
-  // Unwraps `value` and updates the internal state of the unwrapper.
-  int64_t Unwrap(T value) {
-    if (!last_value_) {
-      last_unwrapped_ = {value};
-    } else {
-      last_unwrapped_ += Delta(*last_value_, value);
-    }
-
-    last_value_ = value;
-    return last_unwrapped_;
-  }
-
-  // Returns the `value` without updating the internal state of the unwrapper.
-  int64_t PeekUnwrap(T value) const {
-    if (!last_value_) {
-      return value;
-    }
-    return last_unwrapped_ + Delta(*last_value_, value);
-  }
-
-  // Resets the unwrapper to its initial state. Unwrapped sequence numbers will
-  // being at 0 after resetting.
-  void Reset() {
-    last_unwrapped_ = 0;
-    last_value_.reset();
-  }
-
- private:
-  static int64_t Delta(T last_value, T new_value) {
-    constexpr int64_t kBackwardAdjustment =
-        M == 0 ? int64_t{std::numeric_limits<T>::max()} + 1 : M;
-    int64_t result = ForwardDiff<T, M>(last_value, new_value);
-    if (!AheadOrAt<T, M>(new_value, last_value)) {
-      result -= kBackwardAdjustment;
-    }
-    return result;
-  }
-
-  int64_t last_unwrapped_ = 0;
-  std::unique_ptr<T> last_value_;
-};
-
-using RtpTimestampUnwrapper = SeqNumUnwrapper<uint32_t>;
-using RtpSeqNumUnwrapper = SeqNumUnwrapper<uint16_t>;
-
-#endif