webrtc/modules/video_coding/bitrate_adjuster_unittest.cc - Issue 1914893005: Move BitrateAdjuster into common_video

Side by Side Diff: webrtc/modules/video_coding/bitrate_adjuster_unittest.cc

Issue 1914893005: Move BitrateAdjuster into common_video (Closed) Base URL: https://chromium.googlesource.com/external/webrtc.git@master

Patch Set: Created 4 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 /*

2 * Copyright 2016 The WebRTC project authors. All Rights Reserved.

3 *

4 * Use of this source code is governed by a BSD-style license

5 * that can be found in the LICENSE file in the root of the source

6 * tree. An additional intellectual property rights grant can be found

7 * in the file PATENTS. All contributing project authors may

8 * be found in the AUTHORS file in the root of the source tree.

9 */

10

11 #include "testing/gtest/include/gtest/gtest.h"

12

13 #include "webrtc/modules/video_coding/include/bitrate_adjuster.h"

14 #include "webrtc/system_wrappers/include/clock.h"

15

16 namespace webrtc {

17

18 class BitrateAdjusterTest : public ::testing::Test {

19 public:

20 BitrateAdjusterTest()

21 : clock_(0),

22 adjuster_(&clock_, kMinAdjustedBitratePct, kMaxAdjustedBitratePct) {}

23

24 // Simulate an output bitrate for one update cycle of BitrateAdjuster.

25 void SimulateBitrateBps(uint32_t bitrate_bps) {

26 const uint32_t update_interval_ms =

27 BitrateAdjuster::kBitrateUpdateIntervalMs;

28 const uint32_t update_frame_interval =

29 BitrateAdjuster::kBitrateUpdateFrameInterval;

30 // Round up frame interval so we get one cycle passes.

31 const uint32_t frame_interval_ms =

32 (update_interval_ms + update_frame_interval - 1) /

33 update_frame_interval;

34 const size_t frame_size_bytes =

35 (bitrate_bps * frame_interval_ms) / (8 * 1000);

36 for (size_t i = 0; i < update_frame_interval; ++i) {

37 clock_.AdvanceTimeMilliseconds(frame_interval_ms);

38 adjuster_.Update(frame_size_bytes);

39 }

40 }

41

42 uint32_t GetTargetBitrateBpsPct(float pct) {

43 return pct * adjuster_.GetTargetBitrateBps();

44 }

45

46 void VerifyAdjustment() {

47 // The adjusted bitrate should be between the estimated bitrate and the

48 // target bitrate within clamp.

49 uint32_t target_bitrate_bps = adjuster_.GetTargetBitrateBps();

50 uint32_t adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();

51 uint32_t estimated_bitrate_bps = adjuster_.GetEstimatedBitrateBps();

52 uint32_t adjusted_lower_bound_bps =

53 GetTargetBitrateBpsPct(kMinAdjustedBitratePct);

54 uint32_t adjusted_upper_bound_bps =

55 GetTargetBitrateBpsPct(kMaxAdjustedBitratePct);

56 EXPECT_LE(adjusted_bitrate_bps, adjusted_upper_bound_bps);

57 EXPECT_GE(adjusted_bitrate_bps, adjusted_lower_bound_bps);

58 if (estimated_bitrate_bps > target_bitrate_bps) {

59 EXPECT_LT(adjusted_bitrate_bps, target_bitrate_bps);

60 }

61 }

62

63 protected:

64 static const float kMinAdjustedBitratePct;

65 static const float kMaxAdjustedBitratePct;

66 SimulatedClock clock_;

67 BitrateAdjuster adjuster_;

68 };

69

70 const float BitrateAdjusterTest::kMinAdjustedBitratePct = .5f;

71 const float BitrateAdjusterTest::kMaxAdjustedBitratePct = .95f;

72

73 TEST_F(BitrateAdjusterTest, VaryingBitrates) {

74 const uint32_t target_bitrate_bps = 640000;

75 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

76

77 // Grossly overshoot for a little while. Adjusted bitrate should decrease.

78 uint32_t actual_bitrate_bps = 2 * target_bitrate_bps;

79 uint32_t last_adjusted_bitrate_bps = 0;

80 uint32_t adjusted_bitrate_bps = 0;

81

82 SimulateBitrateBps(actual_bitrate_bps);

83 VerifyAdjustment();

84 last_adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();

85

86 SimulateBitrateBps(actual_bitrate_bps);

87 VerifyAdjustment();

88 adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();

89 EXPECT_LE(adjusted_bitrate_bps, last_adjusted_bitrate_bps);

90 last_adjusted_bitrate_bps = adjusted_bitrate_bps;

91 // After two cycles we should've stabilized and hit the lower bound.

92 EXPECT_EQ(GetTargetBitrateBpsPct(kMinAdjustedBitratePct),

93 adjusted_bitrate_bps);

94

95 // Simulate encoder settling down. Adjusted bitrate should increase.

96 SimulateBitrateBps(target_bitrate_bps);

97 adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();

98 VerifyAdjustment();

99 EXPECT_GT(adjusted_bitrate_bps, last_adjusted_bitrate_bps);

100 last_adjusted_bitrate_bps = adjusted_bitrate_bps;

101

102 SimulateBitrateBps(target_bitrate_bps);

103 adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();

104 VerifyAdjustment();

105 EXPECT_GT(adjusted_bitrate_bps, last_adjusted_bitrate_bps);

106 last_adjusted_bitrate_bps = adjusted_bitrate_bps;

107 // After two cycles we should've stabilized and hit the upper bound.

108 EXPECT_EQ(GetTargetBitrateBpsPct(kMaxAdjustedBitratePct),

109 adjusted_bitrate_bps);

110 }

111

112 // Tests that large changes in target bitrate will result in immediate change

113 // in adjusted bitrate.

114 TEST_F(BitrateAdjusterTest, LargeTargetDelta) {

115 uint32_t target_bitrate_bps = 640000;

116 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

117 EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

118

119 float delta_pct = BitrateAdjuster::kBitrateTolerancePct * 2;

120

121 target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;

122 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

123 EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

124

125 target_bitrate_bps = (1 - delta_pct) * target_bitrate_bps;

126 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

127 EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

128 }

129

130 // Tests that small changes in target bitrate within tolerance will not affect

131 // adjusted bitrate immediately.

132 TEST_F(BitrateAdjusterTest, SmallTargetDelta) {

133 const uint32_t initial_target_bitrate_bps = 640000;

134 uint32_t target_bitrate_bps = initial_target_bitrate_bps;

135 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

136 EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

137

138 float delta_pct = BitrateAdjuster::kBitrateTolerancePct / 2;

139

140 target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;

141 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

142 EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

143

144 target_bitrate_bps = (1 - delta_pct) * target_bitrate_bps;

145 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

146 EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

147 }

148

149 TEST_F(BitrateAdjusterTest, SmallTargetDeltaOverflow) {

150 const uint32_t initial_target_bitrate_bps = 640000;

151 uint32_t target_bitrate_bps = initial_target_bitrate_bps;

152 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

153 EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

154

155 float delta_pct = BitrateAdjuster::kBitrateTolerancePct / 2;

156

157 target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;

158 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

159 EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

160

161 // 1.05 * 1.05 is 1.1 which is greater than tolerance for the initial target

162 // bitrate. Since we didn't advance the clock the adjuster never updated.

163 target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;

164 adjuster_.SetTargetBitrateBps(target_bitrate_bps);

165 EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());

166 }

167

168 } // namespace webrtc

OLD	NEW