zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implemented a new sequence number unwrapper in sequence_number_util.h.

Browse Source 
There is already an Unwrapper in webrtc/modules/include/module_common_types.h,
but we reimplemented it in sequence_number_util.h for a few reasons:
 - Such a class belongs in sequence_number_util.h.
 - It is a cleaner implementation since we can use the rest of
   sequence_number_util.h functionality.
 - You can choose at which number the unwrapped sequence should start,
   which is used to avoid the edge case when a backward wrap can happen
   as the first few numbers are unwrapped.
 - This unwrapper can unwrap numbers that does not wrap 8/16/32 bits.

BUG=None

Review-Url: https://codereview.webrtc.org/2977603002
Cr-Commit-Position: refs/heads/master@{#19154}
This commit is contained in:
philipel
2017-07-26 07:48:15 -07:00
committed by Commit Bot
parent 8de1826b6d
commit 7956c0f2f6
4 changed files with 193 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
webrtc/modules/video_coding/sequence_number_util.h
View File

@ -15,6 +15,8 @@
#include <type_traits>
#include "webrtc/rtc_base/mod_ops.h"
#include "webrtc/rtc_base/optional.h"
#include "webrtc/rtc_base/safe_compare.h"
namespace webrtc {
@ -24,7 +26,7 @@ namespace webrtc {
// from each other, then the sequence number with the highest value is
// considered to be ahead.
template <typename T, T M>
inline bool AheadOrAt(T a, T b) {
inline typename std::enable_if<(M > 0), bool>::type AheadOrAt(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
const T maxDist = M / 2;
@ -33,8 +35,8 @@ inline bool AheadOrAt(T a, T b) {
return ForwardDiff<T, M>(b, a) <= maxDist;
}
template <typename T>
inline bool AheadOrAt(T a, T b) {
template <typename T, T M>
inline typename std::enable_if<(M == 0), bool>::type AheadOrAt(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
const T maxDist = std::numeric_limits<T>::max() / 2 + T(1);
@ -43,66 +45,76 @@ inline bool AheadOrAt(T a, T b) {
return ForwardDiff(b, a) < maxDist;
}
template <typename T>
inline bool AheadOrAt(T a, T b) {
return AheadOrAt<T, 0>(a, b);
}
// Test if the sequence number |a| is ahead of sequence number |b|.
//
// If |M| is an even number and the two sequence numbers are at max distance
// from each other, then the sequence number with the highest value is
// considered to be ahead.
template <typename T, T M>
template <typename T, T M = 0>
inline bool AheadOf(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
return a != b && AheadOrAt<T, M>(a, b);
}
template <typename T>
inline bool AheadOf(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
return a != b && AheadOrAt(a, b);
}
namespace internal {
template <typename T, typename M>
struct SeqNumComp;
template <typename T, T M>
struct SeqNumComp<T, std::integral_constant<T, M>> {
// Comparator used to compare sequence numbers in a continuous fashion.
//
// WARNING! If used to sort sequence numbers of length M then the interval
// covered by the sequence numbers may not be larger than floor(M/2).
template <typename T, T M = 0>
struct AscendingSeqNumComp {
bool operator()(T a, T b) const { return AheadOf<T, M>(a, b); }
};
template <typename T>
struct SeqNumComp<T, std::integral_constant<T, T(0)>> {
bool operator()(T a, T b) const { return AheadOf<T>(a, b); }
};
} // namespace internal
// Comparator used to compare sequence numbers in a continuous fashion.
//
// WARNING! If used to sort sequence numbers of length M then the interval
// covered by the sequence numbers may not be larger than floor(M/2).
template <typename T, T M = 0>
struct AscendingSeqNumComp
: private internal::SeqNumComp<T, std::integral_constant<T, M>> {
bool operator()(T a, T b) const {
return internal::SeqNumComp<T, std::integral_constant<T, M>>::operator()(a,
b);
}
struct DescendingSeqNumComp {
bool operator()(T a, T b) const { return AheadOf<T, M>(b, a); }
};
// Comparator used to compare sequence numbers in a continuous fashion.
//
// WARNING! If used to sort sequence numbers of length M then the interval
// covered by the sequence numbers may not be larger than floor(M/2).
// A sequencer number unwrapper where the start value of the unwrapped sequence
// can be set. The unwrapped value is not allowed to wrap.
template <typename T, T M = 0>
struct DescendingSeqNumComp
: private internal::SeqNumComp<T, std::integral_constant<T, M>> {
bool operator()(T a, T b) const {
return internal::SeqNumComp<T, std::integral_constant<T, M>>::operator()(b,
a);
class SeqNumUnwrapper {
static_assert(
std::is_unsigned<T>::value &&
rtc::SafeLt(std::numeric_limits<T>::max(),
std::numeric_limits<uint64_t>::max()),
"Type unwrapped must be an unsigned integer smaller than uint64_t.");
public:
SeqNumUnwrapper() : last_unwrapped_(0) {}
explicit SeqNumUnwrapper(uint64_t start_at) : last_unwrapped_(start_at) {}
uint64_t Unwrap(T value) {
if (!last_value_)
last_value_.emplace(value);
uint64_t unwrapped = 0;
if (AheadOrAt<T, M>(value, *last_value_)) {
unwrapped = last_unwrapped_ + ForwardDiff<T, M>(*last_value_, value);
RTC_CHECK_GE(unwrapped, last_unwrapped_);
} else {
unwrapped = last_unwrapped_ - ReverseDiff<T, M>(*last_value_, value);
RTC_CHECK_LT(unwrapped, last_unwrapped_);
}
*last_value_ = value;
last_unwrapped_ = unwrapped;
return last_unwrapped_;
}
private:
uint64_t last_unwrapped_;
rtc::Optional<T> last_value_;
};
} // namespace webrtc

104
webrtc/modules/video_coding/sequence_number_util_unittest.cc
View File

@ -209,4 +209,108 @@ TEST_F(TestSeqNumUtil, SeqNumComparatorWithDivisor) {
}
}
TEST(SeqNumUnwrapper, NoBackWardWrap) {
SeqNumUnwrapper<uint8_t> unwrapper;
EXPECT_EQ(0U, unwrapper.Unwrap(0));
// The unwrapped sequence is not allowed to wrap, if that happens the
// SeqNumUnwrapper should have been constructed with a higher start value.
ASSERT_DEATH_IF_SUPPORTED(unwrapper.Unwrap(255), "");
}
TEST(SeqNumUnwrapper, NoForwardWrap) {
SeqNumUnwrapper<uint32_t> unwrapper(std::numeric_limits<uint64_t>::max());
EXPECT_EQ(std::numeric_limits<uint64_t>::max(), unwrapper.Unwrap(0));
// The unwrapped sequence is not allowed to wrap, if that happens the
// SeqNumUnwrapper should have been constructed with a lower start value.
ASSERT_DEATH_IF_SUPPORTED(unwrapper.Unwrap(1), "");
}
TEST(SeqNumUnwrapper, ForwardWrap) {
SeqNumUnwrapper<uint8_t> unwrapper;
EXPECT_EQ(0U, unwrapper.Unwrap(255));
EXPECT_EQ(1U, unwrapper.Unwrap(0));
}
TEST(SeqNumUnwrapper, ForwardWrapWithDivisor) {
SeqNumUnwrapper<uint8_t, 33> unwrapper;
EXPECT_EQ(0U, unwrapper.Unwrap(30));
EXPECT_EQ(6U, unwrapper.Unwrap(3));
}
TEST(SeqNumUnwrapper, BackWardWrap) {
SeqNumUnwrapper<uint8_t> unwrapper(10);
EXPECT_EQ(10U, unwrapper.Unwrap(0));
EXPECT_EQ(8U, unwrapper.Unwrap(254));
}
TEST(SeqNumUnwrapper, BackWardWrapWithDivisor) {
SeqNumUnwrapper<uint8_t, 33> unwrapper(10);
EXPECT_EQ(10U, unwrapper.Unwrap(0));
EXPECT_EQ(8U, unwrapper.Unwrap(31));
}
TEST(SeqNumUnwrapper, Unwrap) {
SeqNumUnwrapper<uint16_t> unwrapper;
const uint16_t kMax = std::numeric_limits<uint16_t>::max();
const uint16_t kMaxDist = kMax / 2 + 1;
EXPECT_EQ(0U, unwrapper.Unwrap(0));
EXPECT_EQ(kMaxDist, unwrapper.Unwrap(kMaxDist));
EXPECT_EQ(0U, unwrapper.Unwrap(0));
EXPECT_EQ(kMaxDist, unwrapper.Unwrap(kMaxDist));
EXPECT_EQ(kMax, unwrapper.Unwrap(kMax));
EXPECT_EQ(kMax + 1U, unwrapper.Unwrap(0));
EXPECT_EQ(kMax, unwrapper.Unwrap(kMax));
EXPECT_EQ(kMaxDist, unwrapper.Unwrap(kMaxDist));
EXPECT_EQ(0U, unwrapper.Unwrap(0));
}
TEST(SeqNumUnwrapper, UnwrapOddDivisor) {
SeqNumUnwrapper<uint8_t, 11> unwrapper(10);
EXPECT_EQ(10U, unwrapper.Unwrap(10));
EXPECT_EQ(11U, unwrapper.Unwrap(0));
EXPECT_EQ(16U, unwrapper.Unwrap(5));
EXPECT_EQ(21U, unwrapper.Unwrap(10));
EXPECT_EQ(22U, unwrapper.Unwrap(0));
EXPECT_EQ(17U, unwrapper.Unwrap(6));
EXPECT_EQ(12U, unwrapper.Unwrap(1));
EXPECT_EQ(7U, unwrapper.Unwrap(7));
EXPECT_EQ(2U, unwrapper.Unwrap(2));
EXPECT_EQ(0U, unwrapper.Unwrap(0));
}
TEST(SeqNumUnwrapper, ManyForwardWraps) {
const int kLargeNumber = 4711;
const int kMaxStep = kLargeNumber / 2;
const int kNumWraps = 100;
SeqNumUnwrapper<uint16_t, kLargeNumber> unwrapper;
uint16_t next_unwrap = 0;
uint64_t expected = 0;
for (int i = 0; i < kNumWraps * 2 + 1; ++i) {
EXPECT_EQ(expected, unwrapper.Unwrap(next_unwrap));
expected += kMaxStep;
next_unwrap = (next_unwrap + kMaxStep) % kLargeNumber;
}
}
TEST(SeqNumUnwrapper, ManyBackwardWraps) {
const int kLargeNumber = 4711;
const int kMaxStep = kLargeNumber / 2;
const int kNumWraps = 100;
SeqNumUnwrapper<uint16_t, kLargeNumber> unwrapper(kLargeNumber * kNumWraps);
uint16_t next_unwrap = 0;
uint64_t expected = kLargeNumber * kNumWraps;
for (uint16_t i = 0; i < kNumWraps * 2 + 1; ++i) {
EXPECT_EQ(expected, unwrapper.Unwrap(next_unwrap));
expected -= kMaxStep;
next_unwrap = (next_unwrap + kMaxStep + 1) % kLargeNumber;
}
}
} // namespace webrtc

35
webrtc/rtc_base/mod_ops.h
View File

@ -59,8 +59,10 @@ inline unsigned long Subtract(unsigned long a, unsigned long b) { // NOLINT
// #################################################
// -->-----> |----->---
//
// If M > 0 then wrapping occurs at M, if M == 0 then wrapping occurs at the
// largest value representable by T.
template <typename T, T M>
inline T ForwardDiff(T a, T b) {
inline typename std::enable_if<(M > 0), T>::type ForwardDiff(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
RTC_DCHECK_LT(a, M);
@ -68,13 +70,18 @@ inline T ForwardDiff(T a, T b) {
return a <= b ? b - a : M - (a - b);
}
template <typename T>
inline T ForwardDiff(T a, T b) {
template <typename T, T M>
inline typename std::enable_if<(M == 0), T>::type ForwardDiff(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
return b - a;
}
template <typename T>
inline T ForwardDiff(T a, T b) {
return ForwardDiff<T, 0>(a, b);
}
// Calculates the reverse difference between two wrapping numbers.
//
// Example:
@ -97,8 +104,10 @@ inline T ForwardDiff(T a, T b) {
// #################################################
// ---<-----| |<-----<--
//
// If M > 0 then wrapping occurs at M, if M == 0 then wrapping occurs at the
// largest value representable by T.
template <typename T, T M>
inline T ReverseDiff(T a, T b) {
inline typename std::enable_if<(M > 0), T>::type ReverseDiff(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
RTC_DCHECK_LT(a, M);
@ -106,30 +115,28 @@ inline T ReverseDiff(T a, T b) {
return b <= a ? a - b : M - (b - a);
}
template <typename T>
inline T ReverseDiff(T a, T b) {
template <typename T, T M>
inline typename std::enable_if<(M == 0), T>::type ReverseDiff(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
return a - b;
}
template <typename T>
inline T ReverseDiff(T a, T b) {
return ReverseDiff<T, 0>(a, b);
}
// Calculates the minimum distance between to wrapping numbers.
//
// The minimum distance is defined as min(ForwardDiff(a, b), ReverseDiff(a, b))
template <typename T, T M>
template <typename T, T M = 0>
inline T MinDiff(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
return std::min(ForwardDiff<T, M>(a, b), ReverseDiff<T, M>(a, b));
}
template <typename T>
inline T MinDiff(T a, T b) {
static_assert(std::is_unsigned<T>::value,
"Type must be an unsigned integer.");
return std::min(ForwardDiff(a, b), ReverseDiff(a, b));
}
} // namespace webrtc
#endif // WEBRTC_RTC_BASE_MOD_OPS_H_

16
webrtc/rtc_base/mod_ops_unittest.cc
View File

@ -87,6 +87,14 @@ TEST_F(TestModOps, ForwardDiff) {
}
}
TEST_F(TestModOps, ForwardDiffWithDivisor) {
ASSERT_EQ(122, (ForwardDiff<uint8_t, 123>(0, 122)));
ASSERT_EQ(0, (ForwardDiff<uint8_t, 123>(122, 122)));
ASSERT_EQ(122, (ForwardDiff<uint8_t, 123>(1, 0)));
ASSERT_EQ(0, (ForwardDiff<uint8_t, 123>(0, 0)));
ASSERT_EQ(1, (ForwardDiff<uint8_t, 123>(122, 0)));
}
TEST_F(TestModOps, ReverseDiff) {
ASSERT_EQ(0u, ReverseDiff(4711u, 4711u));
@ -106,6 +114,14 @@ TEST_F(TestModOps, ReverseDiff) {
}
}
TEST_F(TestModOps, ReverseDiffWithDivisor) {
ASSERT_EQ(1, (ReverseDiff<uint8_t, 123>(0, 122)));
ASSERT_EQ(0, (ReverseDiff<uint8_t, 123>(122, 122)));
ASSERT_EQ(1, (ReverseDiff<uint8_t, 123>(1, 0)));
ASSERT_EQ(0, (ReverseDiff<uint8_t, 123>(0, 0)));
ASSERT_EQ(122, (ReverseDiff<uint8_t, 123>(122, 0)));
}
TEST_F(TestModOps, MinDiff) {
for (uint16_t i = 0; i < 256; ++i) {
ASSERT_EQ(0, MinDiff<uint8_t>(i, i));