OLD | NEW |
1 /* | 1 /* |
2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2016 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 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 | 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 | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include <utility> | 11 #include <utility> |
12 | 12 |
13 #include "webrtc/common_audio/mocks/mock_smoothing_filter.h" | 13 #include "webrtc/common_audio/mocks/mock_smoothing_filter.h" |
14 #include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller.h" | 14 #include "webrtc/modules/audio_coding/audio_network_adaptor/fec_controller_plr_b
ased.h" |
15 #include "webrtc/test/gtest.h" | 15 #include "webrtc/test/gtest.h" |
16 | 16 |
17 namespace webrtc { | 17 namespace webrtc { |
18 | 18 |
19 using ::testing::NiceMock; | 19 using ::testing::NiceMock; |
20 using ::testing::Return; | 20 using ::testing::Return; |
21 using ::testing::_; | 21 using ::testing::_; |
22 | 22 |
23 namespace { | 23 namespace { |
24 | 24 |
(...skipping 13 matching lines...) Expand all Loading... |
38 | 38 |
39 constexpr int kDisablingBandwidthLow = 15000; | 39 constexpr int kDisablingBandwidthLow = 15000; |
40 constexpr float kDisablingPacketLossAtLowBw = 0.08f; | 40 constexpr float kDisablingPacketLossAtLowBw = 0.08f; |
41 constexpr int kDisablingBandwidthHigh = 64000; | 41 constexpr int kDisablingBandwidthHigh = 64000; |
42 constexpr float kDisablingPacketLossAtHighBw = 0.01f; | 42 constexpr float kDisablingPacketLossAtHighBw = 0.01f; |
43 constexpr int kEnablingBandwidthLow = 17000; | 43 constexpr int kEnablingBandwidthLow = 17000; |
44 constexpr float kEnablingPacketLossAtLowBw = 0.1f; | 44 constexpr float kEnablingPacketLossAtLowBw = 0.1f; |
45 constexpr int kEnablingBandwidthHigh = 64000; | 45 constexpr int kEnablingBandwidthHigh = 64000; |
46 constexpr float kEnablingPacketLossAtHighBw = 0.05f; | 46 constexpr float kEnablingPacketLossAtHighBw = 0.05f; |
47 | 47 |
48 struct FecControllerStates { | 48 struct FecControllerPlrBasedTestStates { |
49 std::unique_ptr<FecController> controller; | 49 std::unique_ptr<FecControllerPlrBased> controller; |
50 MockSmoothingFilter* packet_loss_smoother; | 50 MockSmoothingFilter* packet_loss_smoother; |
51 }; | 51 }; |
52 | 52 |
53 FecControllerStates CreateFecController(bool initial_fec_enabled) { | 53 FecControllerPlrBasedTestStates CreateFecControllerPlrBased( |
54 FecControllerStates states; | 54 bool initial_fec_enabled) { |
| 55 FecControllerPlrBasedTestStates states; |
55 std::unique_ptr<MockSmoothingFilter> mock_smoothing_filter( | 56 std::unique_ptr<MockSmoothingFilter> mock_smoothing_filter( |
56 new NiceMock<MockSmoothingFilter>()); | 57 new NiceMock<MockSmoothingFilter>()); |
57 states.packet_loss_smoother = mock_smoothing_filter.get(); | 58 states.packet_loss_smoother = mock_smoothing_filter.get(); |
58 using Threshold = FecController::Config::Threshold; | 59 using Threshold = FecControllerPlrBased::Config::Threshold; |
59 states.controller.reset(new FecController( | 60 states.controller.reset(new FecControllerPlrBased( |
60 FecController::Config( | 61 FecControllerPlrBased::Config( |
61 initial_fec_enabled, | 62 initial_fec_enabled, |
62 Threshold(kEnablingBandwidthLow, kEnablingPacketLossAtLowBw, | 63 Threshold(kEnablingBandwidthLow, kEnablingPacketLossAtLowBw, |
63 kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw), | 64 kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw), |
64 Threshold(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw, | 65 Threshold(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw, |
65 kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw), | 66 kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw), |
66 0, nullptr), | 67 0, nullptr), |
67 std::move(mock_smoothing_filter))); | 68 std::move(mock_smoothing_filter))); |
68 return states; | 69 return states; |
69 } | 70 } |
70 | 71 |
71 void UpdateNetworkMetrics(FecControllerStates* states, | 72 void UpdateNetworkMetrics(FecControllerPlrBasedTestStates* states, |
72 const rtc::Optional<int>& uplink_bandwidth_bps, | 73 const rtc::Optional<int>& uplink_bandwidth_bps, |
73 const rtc::Optional<float>& uplink_packet_loss) { | 74 const rtc::Optional<float>& uplink_packet_loss) { |
74 // UpdateNetworkMetrics can accept multiple network metric updates at once. | 75 // UpdateNetworkMetrics can accept multiple network metric updates at once. |
75 // However, currently, the most used case is to update one metric at a time. | 76 // However, currently, the most used case is to update one metric at a time. |
76 // To reflect this fact, we separate the calls. | 77 // To reflect this fact, we separate the calls. |
77 if (uplink_bandwidth_bps) { | 78 if (uplink_bandwidth_bps) { |
78 Controller::NetworkMetrics network_metrics; | 79 Controller::NetworkMetrics network_metrics; |
79 network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps; | 80 network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps; |
80 states->controller->UpdateNetworkMetrics(network_metrics); | 81 states->controller->UpdateNetworkMetrics(network_metrics); |
81 } | 82 } |
82 if (uplink_packet_loss) { | 83 if (uplink_packet_loss) { |
83 Controller::NetworkMetrics network_metrics; | 84 Controller::NetworkMetrics network_metrics; |
84 network_metrics.uplink_packet_loss_fraction = uplink_packet_loss; | 85 network_metrics.uplink_packet_loss_fraction = uplink_packet_loss; |
85 EXPECT_CALL(*states->packet_loss_smoother, AddSample(*uplink_packet_loss)); | 86 EXPECT_CALL(*states->packet_loss_smoother, AddSample(*uplink_packet_loss)); |
86 states->controller->UpdateNetworkMetrics(network_metrics); | 87 states->controller->UpdateNetworkMetrics(network_metrics); |
87 // This is called during CheckDecision(). | 88 // This is called during CheckDecision(). |
88 EXPECT_CALL(*states->packet_loss_smoother, GetAverage()) | 89 EXPECT_CALL(*states->packet_loss_smoother, GetAverage()) |
89 .WillOnce(Return(rtc::Optional<float>(*uplink_packet_loss))); | 90 .WillOnce(Return(rtc::Optional<float>(*uplink_packet_loss))); |
90 } | 91 } |
91 } | 92 } |
92 | 93 |
93 // Checks that the FEC decision and |uplink_packet_loss_fraction| given by | 94 // Checks that the FEC decision and |uplink_packet_loss_fraction| given by |
94 // |states->controller->MakeDecision| matches |expected_enable_fec| and | 95 // |states->controller->MakeDecision| matches |expected_enable_fec| and |
95 // |expected_uplink_packet_loss_fraction|, respectively. | 96 // |expected_uplink_packet_loss_fraction|, respectively. |
96 void CheckDecision(FecControllerStates* states, | 97 void CheckDecision(FecControllerPlrBasedTestStates* states, |
97 bool expected_enable_fec, | 98 bool expected_enable_fec, |
98 float expected_uplink_packet_loss_fraction) { | 99 float expected_uplink_packet_loss_fraction) { |
99 AudioNetworkAdaptor::EncoderRuntimeConfig config; | 100 AudioNetworkAdaptor::EncoderRuntimeConfig config; |
100 states->controller->MakeDecision(&config); | 101 states->controller->MakeDecision(&config); |
101 EXPECT_EQ(rtc::Optional<bool>(expected_enable_fec), config.enable_fec); | 102 EXPECT_EQ(rtc::Optional<bool>(expected_enable_fec), config.enable_fec); |
102 EXPECT_EQ(rtc::Optional<float>(expected_uplink_packet_loss_fraction), | 103 EXPECT_EQ(rtc::Optional<float>(expected_uplink_packet_loss_fraction), |
103 config.uplink_packet_loss_fraction); | 104 config.uplink_packet_loss_fraction); |
104 } | 105 } |
105 | 106 |
106 } // namespace | 107 } // namespace |
107 | 108 |
108 TEST(FecControllerTest, OutputInitValueWhenUplinkBandwidthUnknown) { | 109 TEST(FecControllerPlrBasedTest, OutputInitValueWhenUplinkBandwidthUnknown) { |
109 constexpr bool kInitialFecEnabled = true; | 110 constexpr bool kInitialFecEnabled = true; |
110 auto states = CreateFecController(kInitialFecEnabled); | 111 auto states = CreateFecControllerPlrBased(kInitialFecEnabled); |
111 // Let uplink packet loss fraction be so low that would cause FEC to turn off | 112 // Let uplink packet loss fraction be so low that would cause FEC to turn off |
112 // if uplink bandwidth was known. | 113 // if uplink bandwidth was known. |
113 UpdateNetworkMetrics(&states, rtc::Optional<int>(), | 114 UpdateNetworkMetrics(&states, rtc::Optional<int>(), |
114 rtc::Optional<float>(kDisablingPacketLossAtHighBw)); | 115 rtc::Optional<float>(kDisablingPacketLossAtHighBw)); |
115 CheckDecision(&states, kInitialFecEnabled, kDisablingPacketLossAtHighBw); | 116 CheckDecision(&states, kInitialFecEnabled, kDisablingPacketLossAtHighBw); |
116 } | 117 } |
117 | 118 |
118 TEST(FecControllerTest, OutputInitValueWhenUplinkPacketLossFractionUnknown) { | 119 TEST(FecControllerPlrBasedTest, |
| 120 OutputInitValueWhenUplinkPacketLossFractionUnknown) { |
119 constexpr bool kInitialFecEnabled = true; | 121 constexpr bool kInitialFecEnabled = true; |
120 auto states = CreateFecController(kInitialFecEnabled); | 122 auto states = CreateFecControllerPlrBased(kInitialFecEnabled); |
121 // Let uplink bandwidth be so low that would cause FEC to turn off if uplink | 123 // Let uplink bandwidth be so low that would cause FEC to turn off if uplink |
122 // bandwidth packet loss fraction was known. | 124 // bandwidth packet loss fraction was known. |
123 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), | 125 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), |
124 rtc::Optional<float>()); | 126 rtc::Optional<float>()); |
125 CheckDecision(&states, kInitialFecEnabled, 0.0); | 127 CheckDecision(&states, kInitialFecEnabled, 0.0); |
126 } | 128 } |
127 | 129 |
128 TEST(FecControllerTest, EnableFecForHighBandwidth) { | 130 TEST(FecControllerPlrBasedTest, EnableFecForHighBandwidth) { |
129 auto states = CreateFecController(false); | 131 auto states = CreateFecControllerPlrBased(false); |
130 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), | 132 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), |
131 rtc::Optional<float>(kEnablingPacketLossAtHighBw)); | 133 rtc::Optional<float>(kEnablingPacketLossAtHighBw)); |
132 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); | 134 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); |
133 } | 135 } |
134 | 136 |
135 TEST(FecControllerTest, UpdateMultipleNetworkMetricsAtOnce) { | 137 TEST(FecControllerPlrBasedTest, UpdateMultipleNetworkMetricsAtOnce) { |
136 // This test is similar to EnableFecForHighBandwidth. But instead of | 138 // This test is similar to EnableFecForHighBandwidth. But instead of |
137 // using ::UpdateNetworkMetrics(...), which calls | 139 // using ::UpdateNetworkMetrics(...), which calls |
138 // FecController::UpdateNetworkMetrics(...) multiple times, we | 140 // FecControllerPlrBased::UpdateNetworkMetrics(...) multiple times, we |
139 // we call it only once. This is to verify that | 141 // we call it only once. This is to verify that |
140 // FecController::UpdateNetworkMetrics(...) can handle multiple | 142 // FecControllerPlrBased::UpdateNetworkMetrics(...) can handle multiple |
141 // network updates at once. This is, however, not a common use case in current | 143 // network updates at once. This is, however, not a common use case in current |
142 // audio_network_adaptor_impl.cc. | 144 // audio_network_adaptor_impl.cc. |
143 auto states = CreateFecController(false); | 145 auto states = CreateFecControllerPlrBased(false); |
144 Controller::NetworkMetrics network_metrics; | 146 Controller::NetworkMetrics network_metrics; |
145 network_metrics.uplink_bandwidth_bps = | 147 network_metrics.uplink_bandwidth_bps = |
146 rtc::Optional<int>(kEnablingBandwidthHigh); | 148 rtc::Optional<int>(kEnablingBandwidthHigh); |
147 network_metrics.uplink_packet_loss_fraction = | 149 network_metrics.uplink_packet_loss_fraction = |
148 rtc::Optional<float>(kEnablingPacketLossAtHighBw); | 150 rtc::Optional<float>(kEnablingPacketLossAtHighBw); |
149 EXPECT_CALL(*states.packet_loss_smoother, GetAverage()) | 151 EXPECT_CALL(*states.packet_loss_smoother, GetAverage()) |
150 .WillOnce(Return(rtc::Optional<float>(kEnablingPacketLossAtHighBw))); | 152 .WillOnce(Return(rtc::Optional<float>(kEnablingPacketLossAtHighBw))); |
151 states.controller->UpdateNetworkMetrics(network_metrics); | 153 states.controller->UpdateNetworkMetrics(network_metrics); |
152 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); | 154 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); |
153 } | 155 } |
154 | 156 |
155 TEST(FecControllerTest, MaintainFecOffForHighBandwidth) { | 157 TEST(FecControllerPlrBasedTest, MaintainFecOffForHighBandwidth) { |
156 auto states = CreateFecController(false); | 158 auto states = CreateFecControllerPlrBased(false); |
157 constexpr float kPacketLoss = kEnablingPacketLossAtHighBw * 0.99f; | 159 constexpr float kPacketLoss = kEnablingPacketLossAtHighBw * 0.99f; |
158 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), | 160 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), |
159 rtc::Optional<float>(kPacketLoss)); | 161 rtc::Optional<float>(kPacketLoss)); |
160 CheckDecision(&states, false, kPacketLoss); | 162 CheckDecision(&states, false, kPacketLoss); |
161 } | 163 } |
162 | 164 |
163 TEST(FecControllerTest, EnableFecForMediumBandwidth) { | 165 TEST(FecControllerPlrBasedTest, EnableFecForMediumBandwidth) { |
164 auto states = CreateFecController(false); | 166 auto states = CreateFecControllerPlrBased(false); |
165 constexpr float kPacketLoss = | 167 constexpr float kPacketLoss = |
166 (kEnablingPacketLossAtLowBw + kEnablingPacketLossAtHighBw) / 2.0; | 168 (kEnablingPacketLossAtLowBw + kEnablingPacketLossAtHighBw) / 2.0; |
167 UpdateNetworkMetrics( | 169 UpdateNetworkMetrics( |
168 &states, | 170 &states, |
169 rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2), | 171 rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2), |
170 rtc::Optional<float>(kPacketLoss)); | 172 rtc::Optional<float>(kPacketLoss)); |
171 CheckDecision(&states, true, kPacketLoss); | 173 CheckDecision(&states, true, kPacketLoss); |
172 } | 174 } |
173 | 175 |
174 TEST(FecControllerTest, MaintainFecOffForMediumBandwidth) { | 176 TEST(FecControllerPlrBasedTest, MaintainFecOffForMediumBandwidth) { |
175 auto states = CreateFecController(false); | 177 auto states = CreateFecControllerPlrBased(false); |
176 constexpr float kPacketLoss = | 178 constexpr float kPacketLoss = |
177 kEnablingPacketLossAtLowBw * 0.49f + kEnablingPacketLossAtHighBw * 0.51f; | 179 kEnablingPacketLossAtLowBw * 0.49f + kEnablingPacketLossAtHighBw * 0.51f; |
178 UpdateNetworkMetrics( | 180 UpdateNetworkMetrics( |
179 &states, | 181 &states, |
180 rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2), | 182 rtc::Optional<int>((kEnablingBandwidthHigh + kEnablingBandwidthLow) / 2), |
181 rtc::Optional<float>(kPacketLoss)); | 183 rtc::Optional<float>(kPacketLoss)); |
182 CheckDecision(&states, false, kPacketLoss); | 184 CheckDecision(&states, false, kPacketLoss); |
183 } | 185 } |
184 | 186 |
185 TEST(FecControllerTest, EnableFecForLowBandwidth) { | 187 TEST(FecControllerPlrBasedTest, EnableFecForLowBandwidth) { |
186 auto states = CreateFecController(false); | 188 auto states = CreateFecControllerPlrBased(false); |
187 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow), | 189 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow), |
188 rtc::Optional<float>(kEnablingPacketLossAtLowBw)); | 190 rtc::Optional<float>(kEnablingPacketLossAtLowBw)); |
189 CheckDecision(&states, true, kEnablingPacketLossAtLowBw); | 191 CheckDecision(&states, true, kEnablingPacketLossAtLowBw); |
190 } | 192 } |
191 | 193 |
192 TEST(FecControllerTest, MaintainFecOffForLowBandwidth) { | 194 TEST(FecControllerPlrBasedTest, MaintainFecOffForLowBandwidth) { |
193 auto states = CreateFecController(false); | 195 auto states = CreateFecControllerPlrBased(false); |
194 constexpr float kPacketLoss = kEnablingPacketLossAtLowBw * 0.99f; | 196 constexpr float kPacketLoss = kEnablingPacketLossAtLowBw * 0.99f; |
195 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow), | 197 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow), |
196 rtc::Optional<float>(kPacketLoss)); | 198 rtc::Optional<float>(kPacketLoss)); |
197 CheckDecision(&states, false, kPacketLoss); | 199 CheckDecision(&states, false, kPacketLoss); |
198 } | 200 } |
199 | 201 |
200 TEST(FecControllerTest, MaintainFecOffForVeryLowBandwidth) { | 202 TEST(FecControllerPlrBasedTest, MaintainFecOffForVeryLowBandwidth) { |
201 auto states = CreateFecController(false); | 203 auto states = CreateFecControllerPlrBased(false); |
202 // Below |kEnablingBandwidthLow|, no packet loss fraction can cause FEC to | 204 // Below |kEnablingBandwidthLow|, no packet loss fraction can cause FEC to |
203 // turn on. | 205 // turn on. |
204 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow - 1), | 206 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthLow - 1), |
205 rtc::Optional<float>(1.0)); | 207 rtc::Optional<float>(1.0)); |
206 CheckDecision(&states, false, 1.0); | 208 CheckDecision(&states, false, 1.0); |
207 } | 209 } |
208 | 210 |
209 TEST(FecControllerTest, DisableFecForHighBandwidth) { | 211 TEST(FecControllerPlrBasedTest, DisableFecForHighBandwidth) { |
210 auto states = CreateFecController(true); | 212 auto states = CreateFecControllerPlrBased(true); |
211 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh), | 213 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh), |
212 rtc::Optional<float>(kDisablingPacketLossAtHighBw)); | 214 rtc::Optional<float>(kDisablingPacketLossAtHighBw)); |
213 CheckDecision(&states, false, kDisablingPacketLossAtHighBw); | 215 CheckDecision(&states, false, kDisablingPacketLossAtHighBw); |
214 } | 216 } |
215 | 217 |
216 TEST(FecControllerTest, MaintainFecOnForHighBandwidth) { | 218 TEST(FecControllerPlrBasedTest, MaintainFecOnForHighBandwidth) { |
217 auto states = CreateFecController(true); | 219 auto states = CreateFecControllerPlrBased(true); |
218 constexpr float kPacketLoss = kDisablingPacketLossAtHighBw * 1.01f; | 220 constexpr float kPacketLoss = kDisablingPacketLossAtHighBw * 1.01f; |
219 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh), | 221 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh), |
220 rtc::Optional<float>(kPacketLoss)); | 222 rtc::Optional<float>(kPacketLoss)); |
221 CheckDecision(&states, true, kPacketLoss); | 223 CheckDecision(&states, true, kPacketLoss); |
222 } | 224 } |
223 | 225 |
224 TEST(FecControllerTest, DisableFecOnMediumBandwidth) { | 226 TEST(FecControllerPlrBasedTest, DisableFecOnMediumBandwidth) { |
225 auto states = CreateFecController(true); | 227 auto states = CreateFecControllerPlrBased(true); |
226 constexpr float kPacketLoss = | 228 constexpr float kPacketLoss = |
227 (kDisablingPacketLossAtLowBw + kDisablingPacketLossAtHighBw) / 2.0f; | 229 (kDisablingPacketLossAtLowBw + kDisablingPacketLossAtHighBw) / 2.0f; |
228 UpdateNetworkMetrics( | 230 UpdateNetworkMetrics( |
229 &states, rtc::Optional<int>( | 231 &states, |
230 (kDisablingBandwidthHigh + kDisablingBandwidthLow) / 2), | 232 rtc::Optional<int>((kDisablingBandwidthHigh + kDisablingBandwidthLow) / |
| 233 2), |
231 rtc::Optional<float>(kPacketLoss)); | 234 rtc::Optional<float>(kPacketLoss)); |
232 CheckDecision(&states, false, kPacketLoss); | 235 CheckDecision(&states, false, kPacketLoss); |
233 } | 236 } |
234 | 237 |
235 TEST(FecControllerTest, MaintainFecOnForMediumBandwidth) { | 238 TEST(FecControllerPlrBasedTest, MaintainFecOnForMediumBandwidth) { |
236 auto states = CreateFecController(true); | 239 auto states = CreateFecControllerPlrBased(true); |
237 constexpr float kPacketLoss = kDisablingPacketLossAtLowBw * 0.51f + | 240 constexpr float kPacketLoss = kDisablingPacketLossAtLowBw * 0.51f + |
238 kDisablingPacketLossAtHighBw * 0.49f; | 241 kDisablingPacketLossAtHighBw * 0.49f; |
239 UpdateNetworkMetrics( | 242 UpdateNetworkMetrics( |
240 &states, | 243 &states, |
241 rtc::Optional<int>((kEnablingBandwidthHigh + kDisablingBandwidthLow) / 2), | 244 rtc::Optional<int>((kEnablingBandwidthHigh + kDisablingBandwidthLow) / 2), |
242 rtc::Optional<float>(kPacketLoss)); | 245 rtc::Optional<float>(kPacketLoss)); |
243 CheckDecision(&states, true, kPacketLoss); | 246 CheckDecision(&states, true, kPacketLoss); |
244 } | 247 } |
245 | 248 |
246 TEST(FecControllerTest, DisableFecForLowBandwidth) { | 249 TEST(FecControllerPlrBasedTest, DisableFecForLowBandwidth) { |
247 auto states = CreateFecController(true); | 250 auto states = CreateFecControllerPlrBased(true); |
248 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow), | 251 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow), |
249 rtc::Optional<float>(kDisablingPacketLossAtLowBw)); | 252 rtc::Optional<float>(kDisablingPacketLossAtLowBw)); |
250 CheckDecision(&states, false, kDisablingPacketLossAtLowBw); | 253 CheckDecision(&states, false, kDisablingPacketLossAtLowBw); |
251 } | 254 } |
252 | 255 |
253 TEST(FecControllerTest, DisableFecForVeryLowBandwidth) { | 256 TEST(FecControllerPlrBasedTest, DisableFecForVeryLowBandwidth) { |
254 auto states = CreateFecController(true); | 257 auto states = CreateFecControllerPlrBased(true); |
255 // Below |kEnablingBandwidthLow|, any packet loss fraction can cause FEC to | 258 // Below |kEnablingBandwidthLow|, any packet loss fraction can cause FEC to |
256 // turn off. | 259 // turn off. |
257 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), | 260 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), |
258 rtc::Optional<float>(1.0)); | 261 rtc::Optional<float>(1.0)); |
259 CheckDecision(&states, false, 1.0); | 262 CheckDecision(&states, false, 1.0); |
260 } | 263 } |
261 | 264 |
262 TEST(FecControllerTest, CheckBehaviorOnChangingNetworkMetrics) { | 265 TEST(FecControllerPlrBasedTest, CheckBehaviorOnChangingNetworkMetrics) { |
263 // In this test, we let the network metrics to traverse from 1 to 5. | 266 // In this test, we let the network metrics to traverse from 1 to 5. |
264 // packet-loss ^ 1 | | | 267 // packet-loss ^ 1 | | |
265 // | | 2| | 268 // | | 2| |
266 // | \ \ 3 | 269 // | \ \ 3 |
267 // | \4 \_______ | 270 // | \4 \_______ |
268 // | \_________ | 271 // | \_________ |
269 // |---------5-------> bandwidth | 272 // |---------5-------> bandwidth |
270 | 273 |
271 auto states = CreateFecController(true); | 274 auto states = CreateFecControllerPlrBased(true); |
272 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), | 275 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), |
273 rtc::Optional<float>(1.0)); | 276 rtc::Optional<float>(1.0)); |
274 CheckDecision(&states, false, 1.0); | 277 CheckDecision(&states, false, 1.0); |
275 | 278 |
276 UpdateNetworkMetrics( | 279 UpdateNetworkMetrics( |
277 &states, rtc::Optional<int>(kEnablingBandwidthLow), | 280 &states, rtc::Optional<int>(kEnablingBandwidthLow), |
278 rtc::Optional<float>(kEnablingPacketLossAtLowBw * 0.99f)); | 281 rtc::Optional<float>(kEnablingPacketLossAtLowBw * 0.99f)); |
279 CheckDecision(&states, false, kEnablingPacketLossAtLowBw * 0.99f); | 282 CheckDecision(&states, false, kEnablingPacketLossAtLowBw * 0.99f); |
280 | 283 |
281 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), | 284 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), |
282 rtc::Optional<float>(kEnablingPacketLossAtHighBw)); | 285 rtc::Optional<float>(kEnablingPacketLossAtHighBw)); |
283 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); | 286 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); |
284 | 287 |
285 UpdateNetworkMetrics( | 288 UpdateNetworkMetrics( |
286 &states, rtc::Optional<int>(kDisablingBandwidthHigh), | 289 &states, rtc::Optional<int>(kDisablingBandwidthHigh), |
287 rtc::Optional<float>(kDisablingPacketLossAtHighBw * 1.01f)); | 290 rtc::Optional<float>(kDisablingPacketLossAtHighBw * 1.01f)); |
288 CheckDecision(&states, true, kDisablingPacketLossAtHighBw * 1.01f); | 291 CheckDecision(&states, true, kDisablingPacketLossAtHighBw * 1.01f); |
289 | 292 |
290 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh + 1), | 293 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh + 1), |
291 rtc::Optional<float>(0.0)); | 294 rtc::Optional<float>(0.0)); |
292 CheckDecision(&states, false, 0.0); | 295 CheckDecision(&states, false, 0.0); |
293 } | 296 } |
294 | 297 |
295 TEST(FecControllerTest, CheckBehaviorOnSpecialCurves) { | 298 TEST(FecControllerPlrBasedTest, CheckBehaviorOnSpecialCurves) { |
296 // We test a special configuration, where the points to define the FEC | 299 // We test a special configuration, where the points to define the FEC |
297 // enabling/disabling curves are placed like the following, otherwise the test | 300 // enabling/disabling curves are placed like the following, otherwise the test |
298 // is the same as CheckBehaviorOnChangingNetworkMetrics. | 301 // is the same as CheckBehaviorOnChangingNetworkMetrics. |
299 // | 302 // |
300 // packet-loss ^ | | | 303 // packet-loss ^ | | |
301 // | | C| | 304 // | | C| |
302 // | | | | 305 // | | | |
303 // | | D|_______ | 306 // | | D|_______ |
304 // | A|___B______ | 307 // | A|___B______ |
305 // |-----------------> bandwidth | 308 // |-----------------> bandwidth |
306 | 309 |
307 constexpr int kEnablingBandwidthHigh = kEnablingBandwidthLow; | 310 constexpr int kEnablingBandwidthHigh = kEnablingBandwidthLow; |
308 constexpr float kDisablingPacketLossAtLowBw = kDisablingPacketLossAtHighBw; | 311 constexpr float kDisablingPacketLossAtLowBw = kDisablingPacketLossAtHighBw; |
309 FecControllerStates states; | 312 FecControllerPlrBasedTestStates states; |
310 std::unique_ptr<MockSmoothingFilter> mock_smoothing_filter( | 313 std::unique_ptr<MockSmoothingFilter> mock_smoothing_filter( |
311 new NiceMock<MockSmoothingFilter>()); | 314 new NiceMock<MockSmoothingFilter>()); |
312 states.packet_loss_smoother = mock_smoothing_filter.get(); | 315 states.packet_loss_smoother = mock_smoothing_filter.get(); |
313 using Threshold = FecController::Config::Threshold; | 316 using Threshold = FecControllerPlrBased::Config::Threshold; |
314 states.controller.reset(new FecController( | 317 states.controller.reset(new FecControllerPlrBased( |
315 FecController::Config( | 318 FecControllerPlrBased::Config( |
316 true, Threshold(kEnablingBandwidthLow, kEnablingPacketLossAtLowBw, | 319 true, |
317 kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw), | 320 Threshold(kEnablingBandwidthLow, kEnablingPacketLossAtLowBw, |
| 321 kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw), |
318 Threshold(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw, | 322 Threshold(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw, |
319 kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw), | 323 kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw), |
320 0, nullptr), | 324 0, nullptr), |
321 std::move(mock_smoothing_filter))); | 325 std::move(mock_smoothing_filter))); |
322 | 326 |
323 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), | 327 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthLow - 1), |
324 rtc::Optional<float>(1.0)); | 328 rtc::Optional<float>(1.0)); |
325 CheckDecision(&states, false, 1.0); | 329 CheckDecision(&states, false, 1.0); |
326 | 330 |
327 UpdateNetworkMetrics( | 331 UpdateNetworkMetrics( |
328 &states, rtc::Optional<int>(kEnablingBandwidthLow), | 332 &states, rtc::Optional<int>(kEnablingBandwidthLow), |
329 rtc::Optional<float>(kEnablingPacketLossAtHighBw * 0.99f)); | 333 rtc::Optional<float>(kEnablingPacketLossAtHighBw * 0.99f)); |
330 CheckDecision(&states, false, kEnablingPacketLossAtHighBw * 0.99f); | 334 CheckDecision(&states, false, kEnablingPacketLossAtHighBw * 0.99f); |
331 | 335 |
332 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), | 336 UpdateNetworkMetrics(&states, rtc::Optional<int>(kEnablingBandwidthHigh), |
333 rtc::Optional<float>(kEnablingPacketLossAtHighBw)); | 337 rtc::Optional<float>(kEnablingPacketLossAtHighBw)); |
334 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); | 338 CheckDecision(&states, true, kEnablingPacketLossAtHighBw); |
335 | 339 |
336 UpdateNetworkMetrics( | 340 UpdateNetworkMetrics( |
337 &states, rtc::Optional<int>(kDisablingBandwidthHigh), | 341 &states, rtc::Optional<int>(kDisablingBandwidthHigh), |
338 rtc::Optional<float>(kDisablingPacketLossAtHighBw * 1.01f)); | 342 rtc::Optional<float>(kDisablingPacketLossAtHighBw * 1.01f)); |
339 CheckDecision(&states, true, kDisablingPacketLossAtHighBw * 1.01f); | 343 CheckDecision(&states, true, kDisablingPacketLossAtHighBw * 1.01f); |
340 | 344 |
341 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh + 1), | 345 UpdateNetworkMetrics(&states, rtc::Optional<int>(kDisablingBandwidthHigh + 1), |
342 rtc::Optional<float>(0.0)); | 346 rtc::Optional<float>(0.0)); |
343 CheckDecision(&states, false, 0.0); | 347 CheckDecision(&states, false, 0.0); |
344 } | 348 } |
345 | 349 |
346 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) | 350 #if RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID) |
347 TEST(FecControllerDeathTest, InvalidConfig) { | 351 TEST(FecControllerPlrBasedDeathTest, InvalidConfig) { |
348 FecControllerStates states; | 352 FecControllerPlrBasedTestStates states; |
349 std::unique_ptr<MockSmoothingFilter> mock_smoothing_filter( | 353 std::unique_ptr<MockSmoothingFilter> mock_smoothing_filter( |
350 new NiceMock<MockSmoothingFilter>()); | 354 new NiceMock<MockSmoothingFilter>()); |
351 states.packet_loss_smoother = mock_smoothing_filter.get(); | 355 states.packet_loss_smoother = mock_smoothing_filter.get(); |
352 using Threshold = FecController::Config::Threshold; | 356 using Threshold = FecControllerPlrBased::Config::Threshold; |
353 EXPECT_DEATH( | 357 EXPECT_DEATH( |
354 states.controller.reset(new FecController( | 358 states.controller.reset(new FecControllerPlrBased( |
355 FecController::Config( | 359 FecControllerPlrBased::Config( |
356 true, | 360 true, |
357 Threshold(kDisablingBandwidthLow - 1, kEnablingPacketLossAtLowBw, | 361 Threshold(kDisablingBandwidthLow - 1, kEnablingPacketLossAtLowBw, |
358 kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw), | 362 kEnablingBandwidthHigh, kEnablingPacketLossAtHighBw), |
359 Threshold(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw, | 363 Threshold(kDisablingBandwidthLow, kDisablingPacketLossAtLowBw, |
360 kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw), | 364 kDisablingBandwidthHigh, kDisablingPacketLossAtHighBw), |
361 0, nullptr), | 365 0, nullptr), |
362 std::move(mock_smoothing_filter))), | 366 std::move(mock_smoothing_filter))), |
363 "Check failed"); | 367 "Check failed"); |
364 } | 368 } |
365 #endif | 369 #endif |
366 | 370 |
367 } // namespace webrtc | 371 } // namespace webrtc |
OLD | NEW |