1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/*
* Copyright 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.
*/
#include "common_video/include/bitrate_adjuster.h"
#include <cstddef>
#include <cstdint>
#include "api/units/time_delta.h"
#include "rtc_base/fake_clock.h"
#include "test/gtest.h"
namespace webrtc {
class BitrateAdjusterTest : public ::testing::Test {
public:
BitrateAdjusterTest()
: adjuster_(kMinAdjustedBitratePct, kMaxAdjustedBitratePct) {}
// Simulate an output bitrate for one update cycle of BitrateAdjuster.
void SimulateBitrateBps(uint32_t bitrate_bps) {
const uint32_t update_interval_ms =
BitrateAdjuster::kBitrateUpdateIntervalMs;
const uint32_t update_frame_interval =
BitrateAdjuster::kBitrateUpdateFrameInterval;
// Round up frame interval so we get one cycle passes.
const uint32_t frame_interval_ms =
(update_interval_ms + update_frame_interval - 1) /
update_frame_interval;
const size_t frame_size_bytes =
(bitrate_bps * frame_interval_ms) / (8 * 1000);
for (size_t i = 0; i < update_frame_interval; ++i) {
clock_.AdvanceTime(TimeDelta::Millis(frame_interval_ms));
adjuster_.Update(frame_size_bytes);
}
}
uint32_t GetTargetBitrateBpsPct(float pct) {
return pct * adjuster_.GetTargetBitrateBps();
}
void VerifyAdjustment() {
// The adjusted bitrate should be between the estimated bitrate and the
// target bitrate within clamp.
uint32_t target_bitrate_bps = adjuster_.GetTargetBitrateBps();
uint32_t adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();
uint32_t estimated_bitrate_bps =
adjuster_.GetEstimatedBitrateBps().value_or(target_bitrate_bps);
uint32_t adjusted_lower_bound_bps =
GetTargetBitrateBpsPct(kMinAdjustedBitratePct);
uint32_t adjusted_upper_bound_bps =
GetTargetBitrateBpsPct(kMaxAdjustedBitratePct);
EXPECT_LE(adjusted_bitrate_bps, adjusted_upper_bound_bps);
EXPECT_GE(adjusted_bitrate_bps, adjusted_lower_bound_bps);
if (estimated_bitrate_bps > target_bitrate_bps) {
EXPECT_LT(adjusted_bitrate_bps, target_bitrate_bps);
}
}
protected:
static const float kMinAdjustedBitratePct;
static const float kMaxAdjustedBitratePct;
ScopedFakeClock clock_;
BitrateAdjuster adjuster_;
};
const float BitrateAdjusterTest::kMinAdjustedBitratePct = .5f;
const float BitrateAdjusterTest::kMaxAdjustedBitratePct = .95f;
TEST_F(BitrateAdjusterTest, VaryingBitrates) {
const uint32_t target_bitrate_bps = 640000;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
// Grossly overshoot for a little while. Adjusted bitrate should decrease.
uint32_t actual_bitrate_bps = 2 * target_bitrate_bps;
uint32_t last_adjusted_bitrate_bps = 0;
uint32_t adjusted_bitrate_bps = 0;
SimulateBitrateBps(actual_bitrate_bps);
VerifyAdjustment();
last_adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();
SimulateBitrateBps(actual_bitrate_bps);
VerifyAdjustment();
adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();
EXPECT_LE(adjusted_bitrate_bps, last_adjusted_bitrate_bps);
last_adjusted_bitrate_bps = adjusted_bitrate_bps;
// After two cycles we should've stabilized and hit the lower bound.
EXPECT_EQ(GetTargetBitrateBpsPct(kMinAdjustedBitratePct),
adjusted_bitrate_bps);
// Simulate encoder settling down. Adjusted bitrate should increase.
SimulateBitrateBps(target_bitrate_bps);
adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();
VerifyAdjustment();
EXPECT_GT(adjusted_bitrate_bps, last_adjusted_bitrate_bps);
last_adjusted_bitrate_bps = adjusted_bitrate_bps;
SimulateBitrateBps(target_bitrate_bps);
adjusted_bitrate_bps = adjuster_.GetAdjustedBitrateBps();
VerifyAdjustment();
EXPECT_GT(adjusted_bitrate_bps, last_adjusted_bitrate_bps);
last_adjusted_bitrate_bps = adjusted_bitrate_bps;
// After two cycles we should've stabilized and hit the upper bound.
EXPECT_EQ(GetTargetBitrateBpsPct(kMaxAdjustedBitratePct),
adjusted_bitrate_bps);
}
// Tests that large changes in target bitrate will result in immediate change
// in adjusted bitrate.
TEST_F(BitrateAdjusterTest, LargeTargetDelta) {
uint32_t target_bitrate_bps = 640000;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
float delta_pct = BitrateAdjuster::kBitrateTolerancePct * 2;
target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
target_bitrate_bps = (1 - delta_pct) * target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
}
// Tests that small changes in target bitrate within tolerance will not affect
// adjusted bitrate immediately.
TEST_F(BitrateAdjusterTest, SmallTargetDelta) {
const uint32_t initial_target_bitrate_bps = 640000;
uint32_t target_bitrate_bps = initial_target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
float delta_pct = BitrateAdjuster::kBitrateTolerancePct / 2;
target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
target_bitrate_bps = (1 - delta_pct) * target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
}
TEST_F(BitrateAdjusterTest, SmallTargetDeltaOverflow) {
const uint32_t initial_target_bitrate_bps = 640000;
uint32_t target_bitrate_bps = initial_target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
float delta_pct = BitrateAdjuster::kBitrateTolerancePct / 2;
target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(initial_target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
// 1.05 * 1.05 is 1.1 which is greater than tolerance for the initial target
// bitrate. Since we didn't advance the clock the adjuster never updated.
target_bitrate_bps = (1 + delta_pct) * target_bitrate_bps;
adjuster_.SetTargetBitrateBps(target_bitrate_bps);
EXPECT_EQ(target_bitrate_bps, adjuster_.GetAdjustedBitrateBps());
}
} // namespace webrtc
|
