1 /*
2 * Copyright (c) 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 "modules/audio_coding/audio_network_adaptor/frame_length_controller.h"
12
13 #include <memory>
14 #include <utility>
15
16 #include "test/gtest.h"
17
18 namespace webrtc {
19
20 namespace {
21
22 constexpr float kFlIncreasingPacketLossFraction = 0.04f;
23 constexpr float kFlDecreasingPacketLossFraction = 0.05f;
24 constexpr int kFlIncreaseOverheadOffset = 0;
25 constexpr int kFlDecreaseOverheadOffset = 0;
26 constexpr int kMinEncoderBitrateBps = 6000;
27 constexpr int kPreventOveruseMarginBps = 5000;
28 constexpr size_t kOverheadBytesPerPacket = 20;
29 constexpr int kFl20msTo60msBandwidthBps = 40000;
30 constexpr int kFl60msTo20msBandwidthBps = 50000;
31 constexpr int kFl60msTo120msBandwidthBps = 30000;
32 constexpr int kFl120msTo60msBandwidthBps = 40000;
33 constexpr int kFl20msTo40msBandwidthBps = 45000;
34 constexpr int kFl40msTo20msBandwidthBps = 50000;
35 constexpr int kFl40msTo60msBandwidthBps = 40000;
36 constexpr int kFl60msTo40msBandwidthBps = 45000;
37
38 constexpr int kMediumBandwidthBps =
39 (kFl40msTo20msBandwidthBps + kFl20msTo40msBandwidthBps) / 2;
40 constexpr float kMediumPacketLossFraction =
41 (kFlDecreasingPacketLossFraction + kFlIncreasingPacketLossFraction) / 2;
42 const std::set<int> kDefaultEncoderFrameLengthsMs = {20, 40, 60, 120};
43
VeryLowBitrate(int frame_length_ms)44 int VeryLowBitrate(int frame_length_ms) {
45 return kMinEncoderBitrateBps + kPreventOveruseMarginBps +
46 (kOverheadBytesPerPacket * 8 * 1000 / frame_length_ms);
47 }
48
CreateController(const std::map<FrameLengthController::Config::FrameLengthChange,int> & frame_length_change_criteria,const std::set<int> & encoder_frame_lengths_ms,int initial_frame_length_ms)49 std::unique_ptr<FrameLengthController> CreateController(
50 const std::map<FrameLengthController::Config::FrameLengthChange, int>&
51 frame_length_change_criteria,
52 const std::set<int>& encoder_frame_lengths_ms,
53 int initial_frame_length_ms) {
54 std::unique_ptr<FrameLengthController> controller(
55 new FrameLengthController(FrameLengthController::Config(
56 encoder_frame_lengths_ms, initial_frame_length_ms,
57 kMinEncoderBitrateBps, kFlIncreasingPacketLossFraction,
58 kFlDecreasingPacketLossFraction, kFlIncreaseOverheadOffset,
59 kFlDecreaseOverheadOffset, frame_length_change_criteria)));
60
61 return controller;
62 }
63
64 std::map<FrameLengthController::Config::FrameLengthChange, int>
CreateChangeCriteriaFor20msAnd60ms()65 CreateChangeCriteriaFor20msAnd60ms() {
66 return std::map<FrameLengthController::Config::FrameLengthChange, int>{
67 {FrameLengthController::Config::FrameLengthChange(20, 60),
68 kFl20msTo60msBandwidthBps},
69 {FrameLengthController::Config::FrameLengthChange(60, 20),
70 kFl60msTo20msBandwidthBps}};
71 }
72
73 std::map<FrameLengthController::Config::FrameLengthChange, int>
CreateChangeCriteriaFor20msAnd40ms()74 CreateChangeCriteriaFor20msAnd40ms() {
75 return std::map<FrameLengthController::Config::FrameLengthChange, int>{
76 {FrameLengthController::Config::FrameLengthChange(20, 40),
77 kFl20msTo40msBandwidthBps},
78 {FrameLengthController::Config::FrameLengthChange(40, 20),
79 kFl40msTo20msBandwidthBps}};
80 }
81
82 std::map<FrameLengthController::Config::FrameLengthChange, int>
CreateChangeCriteriaFor20ms60msAnd120ms()83 CreateChangeCriteriaFor20ms60msAnd120ms() {
84 return std::map<FrameLengthController::Config::FrameLengthChange, int>{
85 {FrameLengthController::Config::FrameLengthChange(20, 60),
86 kFl20msTo60msBandwidthBps},
87 {FrameLengthController::Config::FrameLengthChange(60, 20),
88 kFl60msTo20msBandwidthBps},
89 {FrameLengthController::Config::FrameLengthChange(60, 120),
90 kFl60msTo120msBandwidthBps},
91 {FrameLengthController::Config::FrameLengthChange(120, 60),
92 kFl120msTo60msBandwidthBps}};
93 }
94
95 std::map<FrameLengthController::Config::FrameLengthChange, int>
CreateChangeCriteriaFor20ms40ms60msAnd120ms()96 CreateChangeCriteriaFor20ms40ms60msAnd120ms() {
97 return std::map<FrameLengthController::Config::FrameLengthChange, int>{
98 {FrameLengthController::Config::FrameLengthChange(20, 60),
99 kFl20msTo60msBandwidthBps},
100 {FrameLengthController::Config::FrameLengthChange(60, 20),
101 kFl60msTo20msBandwidthBps},
102 {FrameLengthController::Config::FrameLengthChange(20, 40),
103 kFl20msTo40msBandwidthBps},
104 {FrameLengthController::Config::FrameLengthChange(40, 20),
105 kFl40msTo20msBandwidthBps},
106 {FrameLengthController::Config::FrameLengthChange(40, 60),
107 kFl40msTo60msBandwidthBps},
108 {FrameLengthController::Config::FrameLengthChange(60, 40),
109 kFl60msTo40msBandwidthBps},
110 {FrameLengthController::Config::FrameLengthChange(60, 120),
111 kFl60msTo120msBandwidthBps},
112 {FrameLengthController::Config::FrameLengthChange(120, 60),
113 kFl120msTo60msBandwidthBps}};
114 }
115
116 std::map<FrameLengthController::Config::FrameLengthChange, int>
CreateChangeCriteriaFor40msAnd60ms()117 CreateChangeCriteriaFor40msAnd60ms() {
118 return std::map<FrameLengthController::Config::FrameLengthChange, int>{
119 {FrameLengthController::Config::FrameLengthChange(40, 60),
120 kFl40msTo60msBandwidthBps},
121 {FrameLengthController::Config::FrameLengthChange(60, 40),
122 kFl60msTo40msBandwidthBps}};
123 }
124
UpdateNetworkMetrics(FrameLengthController * controller,const absl::optional<int> & uplink_bandwidth_bps,const absl::optional<float> & uplink_packet_loss_fraction,const absl::optional<size_t> & overhead_bytes_per_packet)125 void UpdateNetworkMetrics(
126 FrameLengthController* controller,
127 const absl::optional<int>& uplink_bandwidth_bps,
128 const absl::optional<float>& uplink_packet_loss_fraction,
129 const absl::optional<size_t>& overhead_bytes_per_packet) {
130 // UpdateNetworkMetrics can accept multiple network metric updates at once.
131 // However, currently, the most used case is to update one metric at a time.
132 // To reflect this fact, we separate the calls.
133 if (uplink_bandwidth_bps) {
134 Controller::NetworkMetrics network_metrics;
135 network_metrics.uplink_bandwidth_bps = uplink_bandwidth_bps;
136 controller->UpdateNetworkMetrics(network_metrics);
137 }
138 if (uplink_packet_loss_fraction) {
139 Controller::NetworkMetrics network_metrics;
140 network_metrics.uplink_packet_loss_fraction = uplink_packet_loss_fraction;
141 controller->UpdateNetworkMetrics(network_metrics);
142 }
143 if (overhead_bytes_per_packet) {
144 Controller::NetworkMetrics network_metrics;
145 network_metrics.overhead_bytes_per_packet = overhead_bytes_per_packet;
146 controller->UpdateNetworkMetrics(network_metrics);
147 }
148 }
149
CheckDecision(FrameLengthController * controller,int expected_frame_length_ms)150 void CheckDecision(FrameLengthController* controller,
151 int expected_frame_length_ms) {
152 AudioEncoderRuntimeConfig config;
153 controller->MakeDecision(&config);
154 EXPECT_EQ(expected_frame_length_ms, config.frame_length_ms);
155 }
156
157 } // namespace
158
TEST(FrameLengthControllerTest,DecreaseTo20MsOnHighUplinkBandwidth)159 TEST(FrameLengthControllerTest, DecreaseTo20MsOnHighUplinkBandwidth) {
160 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
161 kDefaultEncoderFrameLengthsMs, 60);
162 UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
163 absl::nullopt, kOverheadBytesPerPacket);
164 CheckDecision(controller.get(), 20);
165 }
166
TEST(FrameLengthControllerTest,DecreaseTo20MsOnHighUplinkPacketLossFraction)167 TEST(FrameLengthControllerTest, DecreaseTo20MsOnHighUplinkPacketLossFraction) {
168 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
169 kDefaultEncoderFrameLengthsMs, 60);
170 UpdateNetworkMetrics(controller.get(), absl::nullopt,
171 kFlDecreasingPacketLossFraction,
172 kOverheadBytesPerPacket);
173 CheckDecision(controller.get(), 20);
174 }
175
TEST(FrameLengthControllerTest,Maintain60MsIf20MsNotInReceiverFrameLengthRange)176 TEST(FrameLengthControllerTest,
177 Maintain60MsIf20MsNotInReceiverFrameLengthRange) {
178 auto controller =
179 CreateController(CreateChangeCriteriaFor20msAnd60ms(), {60}, 60);
180 // Set FEC on that would cause frame length to decrease if receiver frame
181 // length range included 20ms.
182 CheckDecision(controller.get(), 60);
183 }
184
TEST(FrameLengthControllerTest,IncreaseTo40MsOnMultipleConditions)185 TEST(FrameLengthControllerTest, IncreaseTo40MsOnMultipleConditions) {
186 // Increase to 40ms frame length if
187 // 1. `uplink_bandwidth_bps` is known to be smaller than a threshold AND
188 // 2. `uplink_packet_loss_fraction` is known to be smaller than a threshold
189 // AND
190 // 3. FEC is not decided or OFF.
191 auto controller = CreateController(CreateChangeCriteriaFor20msAnd40ms(),
192 kDefaultEncoderFrameLengthsMs, 20);
193 UpdateNetworkMetrics(controller.get(), kFl20msTo40msBandwidthBps,
194 kFlIncreasingPacketLossFraction,
195 kOverheadBytesPerPacket);
196 CheckDecision(controller.get(), 40);
197 }
198
TEST(FrameLengthControllerTest,DecreaseTo40MsOnHighUplinkBandwidth)199 TEST(FrameLengthControllerTest, DecreaseTo40MsOnHighUplinkBandwidth) {
200 auto controller = CreateController(CreateChangeCriteriaFor40msAnd60ms(),
201 kDefaultEncoderFrameLengthsMs, 40);
202 UpdateNetworkMetrics(controller.get(), kFl60msTo40msBandwidthBps,
203 absl::nullopt, kOverheadBytesPerPacket);
204 CheckDecision(controller.get(), 40);
205 }
206
TEST(FrameLengthControllerTest,Maintain60MsOnMultipleConditions)207 TEST(FrameLengthControllerTest, Maintain60MsOnMultipleConditions) {
208 // Maintain 60ms frame length if
209 // 1. `uplink_bandwidth_bps` is at medium level,
210 // 2. `uplink_packet_loss_fraction` is at medium,
211 // 3. FEC is not decided ON.
212 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
213 kDefaultEncoderFrameLengthsMs, 60);
214 UpdateNetworkMetrics(controller.get(), kMediumBandwidthBps,
215 kMediumPacketLossFraction, kOverheadBytesPerPacket);
216 CheckDecision(controller.get(), 60);
217 }
218
TEST(FrameLengthControllerTest,IncreaseTo60MsOnMultipleConditions)219 TEST(FrameLengthControllerTest, IncreaseTo60MsOnMultipleConditions) {
220 // Increase to 60ms frame length if
221 // 1. `uplink_bandwidth_bps` is known to be smaller than a threshold AND
222 // 2. `uplink_packet_loss_fraction` is known to be smaller than a threshold
223 // AND
224 // 3. FEC is not decided or OFF.
225 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
226 kDefaultEncoderFrameLengthsMs, 20);
227 UpdateNetworkMetrics(controller.get(), kFl20msTo60msBandwidthBps,
228 kFlIncreasingPacketLossFraction,
229 kOverheadBytesPerPacket);
230 CheckDecision(controller.get(), 60);
231 }
232
TEST(FrameLengthControllerTest,IncreaseTo60MsOnVeryLowUplinkBandwidth)233 TEST(FrameLengthControllerTest, IncreaseTo60MsOnVeryLowUplinkBandwidth) {
234 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
235 kDefaultEncoderFrameLengthsMs, 20);
236 // We set packet loss fraction to kFlDecreasingPacketLossFraction, which
237 // should have prevented frame length to increase, if the uplink bandwidth
238 // was not this low.
239 UpdateNetworkMetrics(controller.get(), VeryLowBitrate(20),
240 kFlIncreasingPacketLossFraction,
241 kOverheadBytesPerPacket);
242 CheckDecision(controller.get(), 60);
243 }
244
TEST(FrameLengthControllerTest,Maintain60MsOnVeryLowUplinkBandwidth)245 TEST(FrameLengthControllerTest, Maintain60MsOnVeryLowUplinkBandwidth) {
246 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
247 kDefaultEncoderFrameLengthsMs, 60);
248 // We set packet loss fraction to FlDecreasingPacketLossFraction, which should
249 // have caused the frame length to decrease, if the uplink bandwidth was not
250 // this low.
251 UpdateNetworkMetrics(controller.get(), VeryLowBitrate(20),
252 kFlIncreasingPacketLossFraction,
253 kOverheadBytesPerPacket);
254 CheckDecision(controller.get(), 60);
255 }
256
TEST(FrameLengthControllerTest,UpdateMultipleNetworkMetricsAtOnce)257 TEST(FrameLengthControllerTest, UpdateMultipleNetworkMetricsAtOnce) {
258 // This test is similar to IncreaseTo60MsOnMultipleConditions. But instead of
259 // using ::UpdateNetworkMetrics(...), which calls
260 // FrameLengthController::UpdateNetworkMetrics(...) multiple times, we
261 // we call it only once. This is to verify that
262 // FrameLengthController::UpdateNetworkMetrics(...) can handle multiple
263 // network updates at once. This is, however, not a common use case in current
264 // audio_network_adaptor_impl.cc.
265 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
266 kDefaultEncoderFrameLengthsMs, 20);
267 Controller::NetworkMetrics network_metrics;
268 network_metrics.uplink_bandwidth_bps = kFl20msTo60msBandwidthBps;
269 network_metrics.uplink_packet_loss_fraction = kFlIncreasingPacketLossFraction;
270 controller->UpdateNetworkMetrics(network_metrics);
271 CheckDecision(controller.get(), 60);
272 }
273
TEST(FrameLengthControllerTest,Maintain20MsIf60MsNotInReceiverFrameLengthRange)274 TEST(FrameLengthControllerTest,
275 Maintain20MsIf60MsNotInReceiverFrameLengthRange) {
276 auto controller =
277 CreateController(CreateChangeCriteriaFor20msAnd60ms(), {20}, 20);
278 // Use a low uplink bandwidth and a low uplink packet loss fraction that would
279 // cause frame length to increase if receiver frame length included 60ms.
280 UpdateNetworkMetrics(controller.get(), kFl20msTo60msBandwidthBps,
281 kFlIncreasingPacketLossFraction,
282 kOverheadBytesPerPacket);
283 CheckDecision(controller.get(), 20);
284 }
285
TEST(FrameLengthControllerTest,Maintain20MsOnMediumUplinkBandwidth)286 TEST(FrameLengthControllerTest, Maintain20MsOnMediumUplinkBandwidth) {
287 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
288 kDefaultEncoderFrameLengthsMs, 20);
289 UpdateNetworkMetrics(controller.get(), kMediumBandwidthBps,
290 kFlIncreasingPacketLossFraction,
291 kOverheadBytesPerPacket);
292 CheckDecision(controller.get(), 20);
293 }
294
TEST(FrameLengthControllerTest,Maintain20MsOnMediumUplinkPacketLossFraction)295 TEST(FrameLengthControllerTest, Maintain20MsOnMediumUplinkPacketLossFraction) {
296 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
297 kDefaultEncoderFrameLengthsMs, 20);
298 // Use a low uplink bandwidth that would cause frame length to increase if
299 // uplink packet loss fraction was low.
300 UpdateNetworkMetrics(controller.get(), kFl20msTo60msBandwidthBps,
301 kMediumPacketLossFraction, kOverheadBytesPerPacket);
302 CheckDecision(controller.get(), 20);
303 }
304
TEST(FrameLengthControllerTest,Maintain60MsWhenNo120msCriteriaIsSet)305 TEST(FrameLengthControllerTest, Maintain60MsWhenNo120msCriteriaIsSet) {
306 auto controller = CreateController(CreateChangeCriteriaFor20msAnd60ms(),
307 kDefaultEncoderFrameLengthsMs, 60);
308 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
309 kFlIncreasingPacketLossFraction,
310 kOverheadBytesPerPacket);
311 CheckDecision(controller.get(), 60);
312 }
313
TEST(FrameLengthControllerTest,From120MsTo20MsOnHighUplinkBandwidth)314 TEST(FrameLengthControllerTest, From120MsTo20MsOnHighUplinkBandwidth) {
315 auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
316 kDefaultEncoderFrameLengthsMs, 120);
317 // It takes two steps for frame length to go from 120ms to 20ms.
318 UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
319 absl::nullopt, kOverheadBytesPerPacket);
320 CheckDecision(controller.get(), 60);
321
322 UpdateNetworkMetrics(controller.get(), kFl60msTo20msBandwidthBps,
323 absl::nullopt, kOverheadBytesPerPacket);
324 CheckDecision(controller.get(), 20);
325 }
326
TEST(FrameLengthControllerTest,From120MsTo20MsOnHighUplinkPacketLossFraction)327 TEST(FrameLengthControllerTest, From120MsTo20MsOnHighUplinkPacketLossFraction) {
328 auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
329 kDefaultEncoderFrameLengthsMs, 120);
330 // It takes two steps for frame length to go from 120ms to 20ms.
331 UpdateNetworkMetrics(controller.get(), absl::nullopt,
332 kFlDecreasingPacketLossFraction,
333 kOverheadBytesPerPacket);
334 CheckDecision(controller.get(), 60);
335
336 UpdateNetworkMetrics(controller.get(), absl::nullopt,
337 kFlDecreasingPacketLossFraction,
338 kOverheadBytesPerPacket);
339 CheckDecision(controller.get(), 20);
340 }
341
TEST(FrameLengthControllerTest,Maintain120MsOnVeryLowUplinkBandwidth)342 TEST(FrameLengthControllerTest, Maintain120MsOnVeryLowUplinkBandwidth) {
343 auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
344 kDefaultEncoderFrameLengthsMs, 120);
345 // We set packet loss fraction to FlDecreasingPacketLossFraction, which should
346 // have caused the frame length to decrease, if the uplink bandwidth was not
347 // this low.
348 UpdateNetworkMetrics(controller.get(), VeryLowBitrate(60),
349 kFlDecreasingPacketLossFraction,
350 kOverheadBytesPerPacket);
351 CheckDecision(controller.get(), 120);
352 }
353
TEST(FrameLengthControllerTest,From60MsTo120MsOnVeryLowUplinkBandwidth)354 TEST(FrameLengthControllerTest, From60MsTo120MsOnVeryLowUplinkBandwidth) {
355 auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
356 kDefaultEncoderFrameLengthsMs, 60);
357 // We set packet loss fraction to FlDecreasingPacketLossFraction, which should
358 // have prevented frame length to increase, if the uplink bandwidth was not
359 // this low.
360 UpdateNetworkMetrics(controller.get(), VeryLowBitrate(60),
361 kFlDecreasingPacketLossFraction,
362 kOverheadBytesPerPacket);
363 CheckDecision(controller.get(), 120);
364 }
365
TEST(FrameLengthControllerTest,From20MsTo120MsOnMultipleConditions)366 TEST(FrameLengthControllerTest, From20MsTo120MsOnMultipleConditions) {
367 // Increase to 120ms frame length if
368 // 1. `uplink_bandwidth_bps` is known to be smaller than a threshold AND
369 // 2. `uplink_packet_loss_fraction` is known to be smaller than a threshold.
370 auto controller = CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(),
371 kDefaultEncoderFrameLengthsMs, 20);
372 // It takes two steps for frame length to go from 20ms to 120ms.
373 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
374 kFlIncreasingPacketLossFraction,
375 kOverheadBytesPerPacket);
376 CheckDecision(controller.get(), 60);
377 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
378 kFlIncreasingPacketLossFraction,
379 kOverheadBytesPerPacket);
380 CheckDecision(controller.get(), 120);
381 }
382
TEST(FrameLengthControllerTest,Stall60MsIf120MsNotInReceiverFrameLengthRange)383 TEST(FrameLengthControllerTest, Stall60MsIf120MsNotInReceiverFrameLengthRange) {
384 auto controller =
385 CreateController(CreateChangeCriteriaFor20ms60msAnd120ms(), {20, 60}, 20);
386 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
387 kFlIncreasingPacketLossFraction,
388 kOverheadBytesPerPacket);
389 CheckDecision(controller.get(), 60);
390 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
391 kFlIncreasingPacketLossFraction,
392 kOverheadBytesPerPacket);
393 CheckDecision(controller.get(), 60);
394 }
395
TEST(FrameLengthControllerTest,CheckBehaviorOnChangingNetworkMetrics)396 TEST(FrameLengthControllerTest, CheckBehaviorOnChangingNetworkMetrics) {
397 auto controller =
398 CreateController(CreateChangeCriteriaFor20ms40ms60msAnd120ms(),
399 kDefaultEncoderFrameLengthsMs, 20);
400 UpdateNetworkMetrics(controller.get(), kMediumBandwidthBps,
401 kFlIncreasingPacketLossFraction,
402 kOverheadBytesPerPacket);
403 CheckDecision(controller.get(), 20);
404
405 UpdateNetworkMetrics(controller.get(), kFl20msTo40msBandwidthBps,
406 kFlIncreasingPacketLossFraction,
407 kOverheadBytesPerPacket);
408 CheckDecision(controller.get(), 40);
409
410 UpdateNetworkMetrics(controller.get(), kFl60msTo40msBandwidthBps,
411 kMediumPacketLossFraction, kOverheadBytesPerPacket);
412 CheckDecision(controller.get(), 40);
413
414 UpdateNetworkMetrics(controller.get(), kFl20msTo60msBandwidthBps,
415 kFlIncreasingPacketLossFraction,
416 kOverheadBytesPerPacket);
417 CheckDecision(controller.get(), 60);
418
419 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
420 kMediumPacketLossFraction, kOverheadBytesPerPacket);
421 CheckDecision(controller.get(), 60);
422
423 UpdateNetworkMetrics(controller.get(), kFl60msTo120msBandwidthBps,
424 kFlIncreasingPacketLossFraction,
425 kOverheadBytesPerPacket);
426 CheckDecision(controller.get(), 120);
427
428 UpdateNetworkMetrics(controller.get(), kFl120msTo60msBandwidthBps,
429 kFlIncreasingPacketLossFraction,
430 kOverheadBytesPerPacket);
431 CheckDecision(controller.get(), 60);
432
433 UpdateNetworkMetrics(controller.get(), kFl60msTo40msBandwidthBps,
434 kFlDecreasingPacketLossFraction,
435 kOverheadBytesPerPacket);
436 CheckDecision(controller.get(), 40);
437
438 UpdateNetworkMetrics(controller.get(), kMediumBandwidthBps,
439 kFlDecreasingPacketLossFraction,
440 kOverheadBytesPerPacket);
441 CheckDecision(controller.get(), 20);
442 }
443
444 } // namespace webrtc
445