1 /*
2 * Copyright (c) 2013 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/rtp_rtcp/include/receive_statistics.h"
12
13 #include <cstdint>
14 #include <memory>
15 #include <vector>
16
17 #include "api/units/time_delta.h"
18 #include "modules/rtp_rtcp/source/rtp_packet_received.h"
19 #include "rtc_base/random.h"
20 #include "system_wrappers/include/clock.h"
21 #include "test/gmock.h"
22 #include "test/gtest.h"
23
24 namespace webrtc {
25 namespace {
26
27 using ::testing::SizeIs;
28 using ::testing::UnorderedElementsAre;
29
30 const size_t kPacketSize1 = 100;
31 const size_t kPacketSize2 = 300;
32 const uint32_t kSsrc1 = 101;
33 const uint32_t kSsrc2 = 202;
34 const uint32_t kSsrc3 = 203;
35 const uint32_t kSsrc4 = 304;
36
CreateRtpPacket(uint32_t ssrc,size_t header_size,size_t payload_size,size_t padding_size)37 RtpPacketReceived CreateRtpPacket(uint32_t ssrc,
38 size_t header_size,
39 size_t payload_size,
40 size_t padding_size) {
41 RtpPacketReceived packet;
42 packet.SetSsrc(ssrc);
43 packet.SetSequenceNumber(100);
44 packet.set_payload_type_frequency(90000);
45 RTC_CHECK_GE(header_size, 12);
46 RTC_CHECK_EQ(header_size % 4, 0);
47 if (header_size > 12) {
48 // Insert csrcs to increase header size.
49 const int num_csrcs = (header_size - 12) / 4;
50 std::vector<uint32_t> csrcs(num_csrcs);
51 packet.SetCsrcs(csrcs);
52 }
53 packet.SetPayloadSize(payload_size);
54 packet.SetPadding(padding_size);
55 return packet;
56 }
57
MakeRtpPacket(int payload_type_frequency,uint32_t timestamp)58 RtpPacketReceived MakeRtpPacket(int payload_type_frequency,
59 uint32_t timestamp) {
60 RtpPacketReceived packet =
61 CreateRtpPacket(kSsrc1,
62 /*header_size=*/12, kPacketSize1 - 12,
63 /*padding_size=*/0);
64 packet.SetTimestamp(timestamp);
65 packet.set_payload_type_frequency(payload_type_frequency);
66 return packet;
67 }
68
MakeNextRtpPacket(const RtpPacketReceived & previous_packet,int payload_type_frequency,uint32_t timestamp)69 RtpPacketReceived MakeNextRtpPacket(const RtpPacketReceived& previous_packet,
70 int payload_type_frequency,
71 uint32_t timestamp) {
72 RtpPacketReceived packet = MakeRtpPacket(payload_type_frequency, timestamp);
73 packet.SetSequenceNumber(previous_packet.SequenceNumber() + 1);
74 return packet;
75 }
76
CreateRtpPacket(uint32_t ssrc,size_t packet_size)77 RtpPacketReceived CreateRtpPacket(uint32_t ssrc, size_t packet_size) {
78 return CreateRtpPacket(ssrc, 12, packet_size - 12, 0);
79 }
80
IncrementSequenceNumber(RtpPacketReceived * packet,uint16_t incr)81 void IncrementSequenceNumber(RtpPacketReceived* packet, uint16_t incr) {
82 packet->SetSequenceNumber(packet->SequenceNumber() + incr);
83 }
84
IncrementSequenceNumber(RtpPacketReceived * packet)85 void IncrementSequenceNumber(RtpPacketReceived* packet) {
86 IncrementSequenceNumber(packet, 1);
87 }
88
GetJitter(const ReceiveStatistics & stats)89 uint32_t GetJitter(const ReceiveStatistics& stats) {
90 return stats.GetStatistician(kSsrc1)->GetStats().jitter;
91 }
92
93 class ReceiveStatisticsTest : public ::testing::TestWithParam<bool> {
94 public:
ReceiveStatisticsTest()95 ReceiveStatisticsTest()
96 : clock_(0),
97 receive_statistics_(
98 GetParam() ? ReceiveStatistics::Create(&clock_)
99 : ReceiveStatistics::CreateThreadCompatible(&clock_)) {
100 packet1_ = CreateRtpPacket(kSsrc1, kPacketSize1);
101 packet2_ = CreateRtpPacket(kSsrc2, kPacketSize2);
102 }
103
104 protected:
105 SimulatedClock clock_;
106 std::unique_ptr<ReceiveStatistics> receive_statistics_;
107 RtpPacketReceived packet1_;
108 RtpPacketReceived packet2_;
109 };
110
111 INSTANTIATE_TEST_SUITE_P(All,
112 ReceiveStatisticsTest,
113 ::testing::Bool(),
__anona0c6e1020202(::testing::TestParamInfo<bool> info) 114 [](::testing::TestParamInfo<bool> info) {
115 return info.param ? "WithMutex" : "WithoutMutex";
116 });
117
TEST_P(ReceiveStatisticsTest,TwoIncomingSsrcs)118 TEST_P(ReceiveStatisticsTest, TwoIncomingSsrcs) {
119 receive_statistics_->OnRtpPacket(packet1_);
120 IncrementSequenceNumber(&packet1_);
121 receive_statistics_->OnRtpPacket(packet2_);
122 IncrementSequenceNumber(&packet2_);
123 clock_.AdvanceTimeMilliseconds(100);
124 receive_statistics_->OnRtpPacket(packet1_);
125 IncrementSequenceNumber(&packet1_);
126 receive_statistics_->OnRtpPacket(packet2_);
127 IncrementSequenceNumber(&packet2_);
128
129 StreamStatistician* statistician =
130 receive_statistics_->GetStatistician(kSsrc1);
131 ASSERT_TRUE(statistician != NULL);
132 EXPECT_GT(statistician->BitrateReceived(), 0u);
133 StreamDataCounters counters = statistician->GetReceiveStreamDataCounters();
134 EXPECT_EQ(176u, counters.transmitted.payload_bytes);
135 EXPECT_EQ(24u, counters.transmitted.header_bytes);
136 EXPECT_EQ(0u, counters.transmitted.padding_bytes);
137 EXPECT_EQ(2u, counters.transmitted.packets);
138
139 statistician = receive_statistics_->GetStatistician(kSsrc2);
140 ASSERT_TRUE(statistician != NULL);
141 EXPECT_GT(statistician->BitrateReceived(), 0u);
142 counters = statistician->GetReceiveStreamDataCounters();
143 EXPECT_EQ(576u, counters.transmitted.payload_bytes);
144 EXPECT_EQ(24u, counters.transmitted.header_bytes);
145 EXPECT_EQ(0u, counters.transmitted.padding_bytes);
146 EXPECT_EQ(2u, counters.transmitted.packets);
147
148 EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size());
149 // Add more incoming packets and verify that they are registered in both
150 // access methods.
151 receive_statistics_->OnRtpPacket(packet1_);
152 IncrementSequenceNumber(&packet1_);
153 receive_statistics_->OnRtpPacket(packet2_);
154 IncrementSequenceNumber(&packet2_);
155
156 counters = receive_statistics_->GetStatistician(kSsrc1)
157 ->GetReceiveStreamDataCounters();
158 EXPECT_EQ(264u, counters.transmitted.payload_bytes);
159 EXPECT_EQ(36u, counters.transmitted.header_bytes);
160 EXPECT_EQ(0u, counters.transmitted.padding_bytes);
161 EXPECT_EQ(3u, counters.transmitted.packets);
162
163 counters = receive_statistics_->GetStatistician(kSsrc2)
164 ->GetReceiveStreamDataCounters();
165 EXPECT_EQ(864u, counters.transmitted.payload_bytes);
166 EXPECT_EQ(36u, counters.transmitted.header_bytes);
167 EXPECT_EQ(0u, counters.transmitted.padding_bytes);
168 EXPECT_EQ(3u, counters.transmitted.packets);
169 }
170
TEST_P(ReceiveStatisticsTest,RtcpReportBlocksReturnsMaxBlocksWhenThereAreMoreStatisticians)171 TEST_P(ReceiveStatisticsTest,
172 RtcpReportBlocksReturnsMaxBlocksWhenThereAreMoreStatisticians) {
173 RtpPacketReceived packet1 = CreateRtpPacket(kSsrc1, kPacketSize1);
174 RtpPacketReceived packet2 = CreateRtpPacket(kSsrc2, kPacketSize1);
175 RtpPacketReceived packet3 = CreateRtpPacket(kSsrc3, kPacketSize1);
176 receive_statistics_->OnRtpPacket(packet1);
177 receive_statistics_->OnRtpPacket(packet2);
178 receive_statistics_->OnRtpPacket(packet3);
179
180 EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
181 EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
182 EXPECT_THAT(receive_statistics_->RtcpReportBlocks(2), SizeIs(2));
183 }
184
TEST_P(ReceiveStatisticsTest,RtcpReportBlocksReturnsAllObservedSsrcsWithMultipleCalls)185 TEST_P(ReceiveStatisticsTest,
186 RtcpReportBlocksReturnsAllObservedSsrcsWithMultipleCalls) {
187 RtpPacketReceived packet1 = CreateRtpPacket(kSsrc1, kPacketSize1);
188 RtpPacketReceived packet2 = CreateRtpPacket(kSsrc2, kPacketSize1);
189 RtpPacketReceived packet3 = CreateRtpPacket(kSsrc3, kPacketSize1);
190 RtpPacketReceived packet4 = CreateRtpPacket(kSsrc4, kPacketSize1);
191 receive_statistics_->OnRtpPacket(packet1);
192 receive_statistics_->OnRtpPacket(packet2);
193 receive_statistics_->OnRtpPacket(packet3);
194 receive_statistics_->OnRtpPacket(packet4);
195
196 std::vector<uint32_t> observed_ssrcs;
197 std::vector<rtcp::ReportBlock> report_blocks =
198 receive_statistics_->RtcpReportBlocks(2);
199 ASSERT_THAT(report_blocks, SizeIs(2));
200 observed_ssrcs.push_back(report_blocks[0].source_ssrc());
201 observed_ssrcs.push_back(report_blocks[1].source_ssrc());
202
203 report_blocks = receive_statistics_->RtcpReportBlocks(2);
204 ASSERT_THAT(report_blocks, SizeIs(2));
205 observed_ssrcs.push_back(report_blocks[0].source_ssrc());
206 observed_ssrcs.push_back(report_blocks[1].source_ssrc());
207
208 EXPECT_THAT(observed_ssrcs,
209 UnorderedElementsAre(kSsrc1, kSsrc2, kSsrc3, kSsrc4));
210 }
211
TEST_P(ReceiveStatisticsTest,ActiveStatisticians)212 TEST_P(ReceiveStatisticsTest, ActiveStatisticians) {
213 receive_statistics_->OnRtpPacket(packet1_);
214 IncrementSequenceNumber(&packet1_);
215 clock_.AdvanceTimeMilliseconds(1000);
216 receive_statistics_->OnRtpPacket(packet2_);
217 IncrementSequenceNumber(&packet2_);
218 // Nothing should time out since only 1000 ms has passed since the first
219 // packet came in.
220 EXPECT_EQ(2u, receive_statistics_->RtcpReportBlocks(3).size());
221
222 clock_.AdvanceTimeMilliseconds(7000);
223 // kSsrc1 should have timed out.
224 EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
225
226 clock_.AdvanceTimeMilliseconds(1000);
227 // kSsrc2 should have timed out.
228 EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size());
229
230 receive_statistics_->OnRtpPacket(packet1_);
231 IncrementSequenceNumber(&packet1_);
232 // kSsrc1 should be active again and the data counters should have survived.
233 EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
234 StreamStatistician* statistician =
235 receive_statistics_->GetStatistician(kSsrc1);
236 ASSERT_TRUE(statistician != NULL);
237 StreamDataCounters counters = statistician->GetReceiveStreamDataCounters();
238 EXPECT_EQ(176u, counters.transmitted.payload_bytes);
239 EXPECT_EQ(24u, counters.transmitted.header_bytes);
240 EXPECT_EQ(0u, counters.transmitted.padding_bytes);
241 EXPECT_EQ(2u, counters.transmitted.packets);
242 }
243
TEST_P(ReceiveStatisticsTest,DoesntCreateRtcpReportBlockUntilFirstReceivedPacketForSsrc)244 TEST_P(ReceiveStatisticsTest,
245 DoesntCreateRtcpReportBlockUntilFirstReceivedPacketForSsrc) {
246 // Creates a statistician object for the ssrc.
247 receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
248 EXPECT_TRUE(receive_statistics_->GetStatistician(kSsrc1) != nullptr);
249 EXPECT_EQ(0u, receive_statistics_->RtcpReportBlocks(3).size());
250 // Receive first packet
251 receive_statistics_->OnRtpPacket(packet1_);
252 EXPECT_EQ(1u, receive_statistics_->RtcpReportBlocks(3).size());
253 }
254
TEST_P(ReceiveStatisticsTest,GetReceiveStreamDataCounters)255 TEST_P(ReceiveStatisticsTest, GetReceiveStreamDataCounters) {
256 receive_statistics_->OnRtpPacket(packet1_);
257 StreamStatistician* statistician =
258 receive_statistics_->GetStatistician(kSsrc1);
259 ASSERT_TRUE(statistician != NULL);
260
261 StreamDataCounters counters = statistician->GetReceiveStreamDataCounters();
262 EXPECT_GT(counters.first_packet_time_ms, -1);
263 EXPECT_EQ(1u, counters.transmitted.packets);
264
265 receive_statistics_->OnRtpPacket(packet1_);
266 counters = statistician->GetReceiveStreamDataCounters();
267 EXPECT_GT(counters.first_packet_time_ms, -1);
268 EXPECT_EQ(2u, counters.transmitted.packets);
269 }
270
TEST_P(ReceiveStatisticsTest,SimpleLossComputation)271 TEST_P(ReceiveStatisticsTest, SimpleLossComputation) {
272 packet1_.SetSequenceNumber(1);
273 receive_statistics_->OnRtpPacket(packet1_);
274 packet1_.SetSequenceNumber(3);
275 receive_statistics_->OnRtpPacket(packet1_);
276 packet1_.SetSequenceNumber(4);
277 receive_statistics_->OnRtpPacket(packet1_);
278 packet1_.SetSequenceNumber(5);
279 receive_statistics_->OnRtpPacket(packet1_);
280
281 std::vector<rtcp::ReportBlock> report_blocks =
282 receive_statistics_->RtcpReportBlocks(1);
283 ASSERT_THAT(report_blocks, SizeIs(1));
284 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
285
286 // 20% = 51/255.
287 EXPECT_EQ(51u, report_blocks[0].fraction_lost());
288 EXPECT_EQ(1, report_blocks[0].cumulative_lost_signed());
289 StreamStatistician* statistician =
290 receive_statistics_->GetStatistician(kSsrc1);
291 EXPECT_EQ(20, statistician->GetFractionLostInPercent());
292 }
293
TEST_P(ReceiveStatisticsTest,LossComputationWithReordering)294 TEST_P(ReceiveStatisticsTest, LossComputationWithReordering) {
295 packet1_.SetSequenceNumber(1);
296 receive_statistics_->OnRtpPacket(packet1_);
297 packet1_.SetSequenceNumber(3);
298 receive_statistics_->OnRtpPacket(packet1_);
299 packet1_.SetSequenceNumber(2);
300 receive_statistics_->OnRtpPacket(packet1_);
301 packet1_.SetSequenceNumber(5);
302 receive_statistics_->OnRtpPacket(packet1_);
303
304 std::vector<rtcp::ReportBlock> report_blocks =
305 receive_statistics_->RtcpReportBlocks(1);
306 ASSERT_THAT(report_blocks, SizeIs(1));
307 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
308
309 // 20% = 51/255.
310 EXPECT_EQ(51u, report_blocks[0].fraction_lost());
311 EXPECT_EQ(1, report_blocks[0].cumulative_lost_signed());
312 StreamStatistician* statistician =
313 receive_statistics_->GetStatistician(kSsrc1);
314 EXPECT_EQ(20, statistician->GetFractionLostInPercent());
315 }
316
TEST_P(ReceiveStatisticsTest,LossComputationWithDuplicates)317 TEST_P(ReceiveStatisticsTest, LossComputationWithDuplicates) {
318 // Lose 2 packets, but also receive 1 duplicate. Should actually count as
319 // only 1 packet being lost.
320 packet1_.SetSequenceNumber(1);
321 receive_statistics_->OnRtpPacket(packet1_);
322 packet1_.SetSequenceNumber(4);
323 receive_statistics_->OnRtpPacket(packet1_);
324 packet1_.SetSequenceNumber(4);
325 receive_statistics_->OnRtpPacket(packet1_);
326 packet1_.SetSequenceNumber(5);
327 receive_statistics_->OnRtpPacket(packet1_);
328
329 std::vector<rtcp::ReportBlock> report_blocks =
330 receive_statistics_->RtcpReportBlocks(1);
331 ASSERT_THAT(report_blocks, SizeIs(1));
332 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
333
334 // 20% = 51/255.
335 EXPECT_EQ(51u, report_blocks[0].fraction_lost());
336 EXPECT_EQ(1, report_blocks[0].cumulative_lost_signed());
337 StreamStatistician* statistician =
338 receive_statistics_->GetStatistician(kSsrc1);
339 EXPECT_EQ(20, statistician->GetFractionLostInPercent());
340 }
341
TEST_P(ReceiveStatisticsTest,LossComputationWithSequenceNumberWrapping)342 TEST_P(ReceiveStatisticsTest, LossComputationWithSequenceNumberWrapping) {
343 // First, test loss computation over a period that included a sequence number
344 // rollover.
345 packet1_.SetSequenceNumber(0xfffd);
346 receive_statistics_->OnRtpPacket(packet1_);
347 packet1_.SetSequenceNumber(0);
348 receive_statistics_->OnRtpPacket(packet1_);
349 packet1_.SetSequenceNumber(0xfffe);
350 receive_statistics_->OnRtpPacket(packet1_);
351 packet1_.SetSequenceNumber(1);
352 receive_statistics_->OnRtpPacket(packet1_);
353
354 // Only one packet was actually lost, 0xffff.
355 std::vector<rtcp::ReportBlock> report_blocks =
356 receive_statistics_->RtcpReportBlocks(1);
357 ASSERT_THAT(report_blocks, SizeIs(1));
358 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
359
360 // 20% = 51/255.
361 EXPECT_EQ(51u, report_blocks[0].fraction_lost());
362 EXPECT_EQ(1, report_blocks[0].cumulative_lost_signed());
363 StreamStatistician* statistician =
364 receive_statistics_->GetStatistician(kSsrc1);
365 EXPECT_EQ(20, statistician->GetFractionLostInPercent());
366
367 // Now test losing one packet *after* the rollover.
368 packet1_.SetSequenceNumber(3);
369 receive_statistics_->OnRtpPacket(packet1_);
370
371 report_blocks = receive_statistics_->RtcpReportBlocks(1);
372 ASSERT_THAT(report_blocks, SizeIs(1));
373 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
374
375 // 50% = 127/255.
376 EXPECT_EQ(127u, report_blocks[0].fraction_lost());
377 EXPECT_EQ(2, report_blocks[0].cumulative_lost_signed());
378 // 2 packets lost, 7 expected
379 EXPECT_EQ(28, statistician->GetFractionLostInPercent());
380 }
381
TEST_P(ReceiveStatisticsTest,StreamRestartDoesntCountAsLoss)382 TEST_P(ReceiveStatisticsTest, StreamRestartDoesntCountAsLoss) {
383 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
384
385 packet1_.SetSequenceNumber(0);
386 receive_statistics_->OnRtpPacket(packet1_);
387 packet1_.SetSequenceNumber(1);
388 receive_statistics_->OnRtpPacket(packet1_);
389
390 packet1_.SetSequenceNumber(400);
391 receive_statistics_->OnRtpPacket(packet1_);
392
393 std::vector<rtcp::ReportBlock> report_blocks =
394 receive_statistics_->RtcpReportBlocks(1);
395 ASSERT_THAT(report_blocks, SizeIs(1));
396 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
397
398 EXPECT_EQ(0, report_blocks[0].fraction_lost());
399 EXPECT_EQ(0, report_blocks[0].cumulative_lost_signed());
400 StreamStatistician* statistician =
401 receive_statistics_->GetStatistician(kSsrc1);
402 EXPECT_EQ(0, statistician->GetFractionLostInPercent());
403
404 packet1_.SetSequenceNumber(401);
405 receive_statistics_->OnRtpPacket(packet1_);
406 report_blocks = receive_statistics_->RtcpReportBlocks(1);
407 ASSERT_THAT(report_blocks, SizeIs(1));
408 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
409
410 EXPECT_EQ(0, report_blocks[0].fraction_lost());
411 EXPECT_EQ(0, report_blocks[0].cumulative_lost_signed());
412 EXPECT_EQ(0, statistician->GetFractionLostInPercent());
413 }
414
TEST_P(ReceiveStatisticsTest,CountsLossAfterStreamRestart)415 TEST_P(ReceiveStatisticsTest, CountsLossAfterStreamRestart) {
416 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
417
418 packet1_.SetSequenceNumber(0);
419 receive_statistics_->OnRtpPacket(packet1_);
420 packet1_.SetSequenceNumber(1);
421 receive_statistics_->OnRtpPacket(packet1_);
422
423 packet1_.SetSequenceNumber(400);
424 receive_statistics_->OnRtpPacket(packet1_);
425 packet1_.SetSequenceNumber(401);
426 receive_statistics_->OnRtpPacket(packet1_);
427 packet1_.SetSequenceNumber(403);
428 receive_statistics_->OnRtpPacket(packet1_);
429
430 std::vector<rtcp::ReportBlock> report_blocks =
431 receive_statistics_->RtcpReportBlocks(1);
432 ASSERT_THAT(report_blocks, SizeIs(1));
433 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
434
435 EXPECT_EQ(1, report_blocks[0].cumulative_lost_signed());
436
437 StreamStatistician* statistician =
438 receive_statistics_->GetStatistician(kSsrc1);
439 // Is this reasonable? */
440 EXPECT_EQ(0, statistician->GetFractionLostInPercent());
441 }
442
TEST_P(ReceiveStatisticsTest,StreamCanRestartAtSequenceNumberWrapAround)443 TEST_P(ReceiveStatisticsTest, StreamCanRestartAtSequenceNumberWrapAround) {
444 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
445
446 packet1_.SetSequenceNumber(0xffff - 401);
447 receive_statistics_->OnRtpPacket(packet1_);
448 packet1_.SetSequenceNumber(0xffff - 400);
449 receive_statistics_->OnRtpPacket(packet1_);
450
451 packet1_.SetSequenceNumber(0xffff);
452 receive_statistics_->OnRtpPacket(packet1_);
453 packet1_.SetSequenceNumber(0);
454 receive_statistics_->OnRtpPacket(packet1_);
455 packet1_.SetSequenceNumber(2);
456 receive_statistics_->OnRtpPacket(packet1_);
457
458 std::vector<rtcp::ReportBlock> report_blocks =
459 receive_statistics_->RtcpReportBlocks(1);
460 ASSERT_THAT(report_blocks, SizeIs(1));
461 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
462
463 EXPECT_EQ(1, report_blocks[0].cumulative_lost_signed());
464 }
465
TEST_P(ReceiveStatisticsTest,StreamRestartNeedsTwoConsecutivePackets)466 TEST_P(ReceiveStatisticsTest, StreamRestartNeedsTwoConsecutivePackets) {
467 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
468
469 packet1_.SetSequenceNumber(400);
470 receive_statistics_->OnRtpPacket(packet1_);
471 packet1_.SetSequenceNumber(401);
472 receive_statistics_->OnRtpPacket(packet1_);
473
474 packet1_.SetSequenceNumber(1);
475 receive_statistics_->OnRtpPacket(packet1_);
476 packet1_.SetSequenceNumber(3);
477 receive_statistics_->OnRtpPacket(packet1_);
478
479 std::vector<rtcp::ReportBlock> report_blocks =
480 receive_statistics_->RtcpReportBlocks(1);
481 ASSERT_THAT(report_blocks, SizeIs(1));
482 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
483
484 EXPECT_EQ(401u, report_blocks[0].extended_high_seq_num());
485
486 packet1_.SetSequenceNumber(4);
487 receive_statistics_->OnRtpPacket(packet1_);
488
489 report_blocks = receive_statistics_->RtcpReportBlocks(1);
490 ASSERT_THAT(report_blocks, SizeIs(1));
491 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
492
493 EXPECT_EQ(4u, report_blocks[0].extended_high_seq_num());
494 }
495
TEST_P(ReceiveStatisticsTest,WrapsAroundExtendedHighestSequenceNumber)496 TEST_P(ReceiveStatisticsTest, WrapsAroundExtendedHighestSequenceNumber) {
497 packet1_.SetSequenceNumber(0xffff);
498 receive_statistics_->OnRtpPacket(packet1_);
499
500 std::vector<rtcp::ReportBlock> report_blocks =
501 receive_statistics_->RtcpReportBlocks(1);
502 ASSERT_THAT(report_blocks, SizeIs(1));
503 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
504
505 EXPECT_EQ(0xffffu, report_blocks[0].extended_high_seq_num());
506
507 // Wrap around.
508 packet1_.SetSequenceNumber(1);
509 receive_statistics_->OnRtpPacket(packet1_);
510
511 report_blocks = receive_statistics_->RtcpReportBlocks(1);
512 ASSERT_THAT(report_blocks, SizeIs(1));
513 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
514
515 EXPECT_EQ(0x10001u, report_blocks[0].extended_high_seq_num());
516
517 // Should be treated as out of order; shouldn't increment highest extended
518 // sequence number.
519 packet1_.SetSequenceNumber(0x10000 - 6);
520 report_blocks = receive_statistics_->RtcpReportBlocks(1);
521 ASSERT_THAT(report_blocks, SizeIs(1));
522 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
523
524 EXPECT_EQ(0x10001u, report_blocks[0].extended_high_seq_num());
525
526 // Receive a couple packets then wrap around again.
527 receive_statistics_->SetMaxReorderingThreshold(kSsrc1, 200);
528 for (int i = 10; i < 0xffff; i += 150) {
529 packet1_.SetSequenceNumber(i);
530 receive_statistics_->OnRtpPacket(packet1_);
531 }
532 packet1_.SetSequenceNumber(1);
533 receive_statistics_->OnRtpPacket(packet1_);
534 report_blocks = receive_statistics_->RtcpReportBlocks(1);
535 ASSERT_THAT(report_blocks, SizeIs(1));
536 EXPECT_EQ(kSsrc1, report_blocks[0].source_ssrc());
537
538 EXPECT_EQ(0x20001u, report_blocks[0].extended_high_seq_num());
539 }
540
TEST_P(ReceiveStatisticsTest,StreamDataCounters)541 TEST_P(ReceiveStatisticsTest, StreamDataCounters) {
542 receive_statistics_->EnableRetransmitDetection(kSsrc1, true);
543
544 const size_t kHeaderLength = 20;
545 const size_t kPaddingLength = 9;
546
547 // One packet with payload size kPacketSize1.
548 RtpPacketReceived packet1 =
549 CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 0);
550 receive_statistics_->OnRtpPacket(packet1);
551 StreamDataCounters counters = receive_statistics_->GetStatistician(kSsrc1)
552 ->GetReceiveStreamDataCounters();
553 EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1);
554 EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength);
555 EXPECT_EQ(counters.transmitted.padding_bytes, 0u);
556 EXPECT_EQ(counters.transmitted.packets, 1u);
557 EXPECT_EQ(counters.retransmitted.payload_bytes, 0u);
558 EXPECT_EQ(counters.retransmitted.header_bytes, 0u);
559 EXPECT_EQ(counters.retransmitted.padding_bytes, 0u);
560 EXPECT_EQ(counters.retransmitted.packets, 0u);
561 EXPECT_EQ(counters.fec.packets, 0u);
562
563 // Another packet of size kPacketSize1 with 9 bytes padding.
564 RtpPacketReceived packet2 =
565 CreateRtpPacket(kSsrc1, kHeaderLength, kPacketSize1, 9);
566 packet2.SetSequenceNumber(packet1.SequenceNumber() + 1);
567 clock_.AdvanceTimeMilliseconds(5);
568 receive_statistics_->OnRtpPacket(packet2);
569 counters = receive_statistics_->GetStatistician(kSsrc1)
570 ->GetReceiveStreamDataCounters();
571 EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 2);
572 EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 2);
573 EXPECT_EQ(counters.transmitted.padding_bytes, kPaddingLength);
574 EXPECT_EQ(counters.transmitted.packets, 2u);
575
576 clock_.AdvanceTimeMilliseconds(5);
577 // Retransmit last packet.
578 receive_statistics_->OnRtpPacket(packet2);
579 counters = receive_statistics_->GetStatistician(kSsrc1)
580 ->GetReceiveStreamDataCounters();
581 EXPECT_EQ(counters.transmitted.payload_bytes, kPacketSize1 * 3);
582 EXPECT_EQ(counters.transmitted.header_bytes, kHeaderLength * 3);
583 EXPECT_EQ(counters.transmitted.padding_bytes, kPaddingLength * 2);
584 EXPECT_EQ(counters.transmitted.packets, 3u);
585 EXPECT_EQ(counters.retransmitted.payload_bytes, kPacketSize1);
586 EXPECT_EQ(counters.retransmitted.header_bytes, kHeaderLength);
587 EXPECT_EQ(counters.retransmitted.padding_bytes, kPaddingLength);
588 EXPECT_EQ(counters.retransmitted.packets, 1u);
589 }
590
TEST_P(ReceiveStatisticsTest,LastPacketReceivedTimestamp)591 TEST_P(ReceiveStatisticsTest, LastPacketReceivedTimestamp) {
592 clock_.AdvanceTimeMilliseconds(42);
593 receive_statistics_->OnRtpPacket(packet1_);
594 StreamDataCounters counters = receive_statistics_->GetStatistician(kSsrc1)
595 ->GetReceiveStreamDataCounters();
596
597 EXPECT_EQ(42, counters.last_packet_received_timestamp_ms);
598
599 clock_.AdvanceTimeMilliseconds(3);
600 receive_statistics_->OnRtpPacket(packet1_);
601 counters = receive_statistics_->GetStatistician(kSsrc1)
602 ->GetReceiveStreamDataCounters();
603 EXPECT_EQ(45, counters.last_packet_received_timestamp_ms);
604 }
605
TEST_P(ReceiveStatisticsTest,SimpleJitterComputation)606 TEST_P(ReceiveStatisticsTest, SimpleJitterComputation) {
607 const int kMsPerPacket = 20;
608 const int kCodecSampleRate = 48'000;
609 const int kSamplesPerPacket = kMsPerPacket * kCodecSampleRate / 1'000;
610 const int kLateArrivalDeltaMs = 100;
611 const int kLateArrivalDeltaSamples =
612 kLateArrivalDeltaMs * kCodecSampleRate / 1'000;
613
614 packet1_.set_payload_type_frequency(kCodecSampleRate);
615 packet1_.SetSequenceNumber(1);
616 packet1_.SetTimestamp(0);
617 receive_statistics_->OnRtpPacket(packet1_);
618 packet1_.SetSequenceNumber(2);
619 packet1_.SetTimestamp(kSamplesPerPacket);
620 // Arrives 100 ms late.
621 clock_.AdvanceTimeMilliseconds(kMsPerPacket + kLateArrivalDeltaMs);
622 receive_statistics_->OnRtpPacket(packet1_);
623
624 StreamStatistician* statistician =
625 receive_statistics_->GetStatistician(kSsrc1);
626 // See jitter caluculation in https://www.rfc-editor.org/rfc/rfc3550 6.4.1.
627 const uint32_t expected_jitter = (kLateArrivalDeltaSamples) / 16;
628 EXPECT_EQ(expected_jitter, statistician->GetStats().jitter);
629 EXPECT_EQ(webrtc::TimeDelta::Seconds(expected_jitter) / kCodecSampleRate,
630 statistician->GetStats().interarrival_jitter);
631 }
632
TEST(ReviseJitterTest,AllPacketsHaveSamePayloadTypeFrequency)633 TEST(ReviseJitterTest, AllPacketsHaveSamePayloadTypeFrequency) {
634 SimulatedClock clock(0);
635 std::unique_ptr<ReceiveStatistics> statistics =
636 ReceiveStatistics::Create(&clock);
637 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/8'000,
638 /*timestamp=*/1);
639 RtpPacketReceived packet2 = MakeNextRtpPacket(
640 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
641
642 RtpPacketReceived packet3 = MakeNextRtpPacket(
643 packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 2 * 160);
644
645 statistics->OnRtpPacket(packet1);
646 clock.AdvanceTimeMilliseconds(50);
647 statistics->OnRtpPacket(packet2);
648 clock.AdvanceTimeMilliseconds(50);
649 statistics->OnRtpPacket(packet3);
650
651 // packet1: no jitter calculation
652 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
653 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
654 // / 16 = 240
655 // packet3: jitter = 240[jitter] + (abs(50[receive time ms] *
656 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 240[jitter] + 8)
657 // / 16 = 465
658 // final jitter: 465 / 16 = 29
659 EXPECT_EQ(GetJitter(*statistics), 29U);
660 }
661
TEST(ReviseJitterTest,AllPacketsHaveDifferentPayloadTypeFrequency)662 TEST(ReviseJitterTest, AllPacketsHaveDifferentPayloadTypeFrequency) {
663 SimulatedClock clock(0);
664 std::unique_ptr<ReceiveStatistics> statistics =
665 ReceiveStatistics::Create(&clock);
666 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/8'000,
667 /*timestamp=*/1);
668 RtpPacketReceived packet2 = MakeNextRtpPacket(
669 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
670 RtpPacketReceived packet3 = MakeNextRtpPacket(
671 packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960);
672
673 statistics->OnRtpPacket(packet1);
674 clock.AdvanceTimeMilliseconds(50);
675 statistics->OnRtpPacket(packet2);
676 clock.AdvanceTimeMilliseconds(50);
677 statistics->OnRtpPacket(packet3);
678
679 // packet1: no jitter calculation
680 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
681 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
682 // / 16 = 240
683 // packet3: revised jitter: 240 * 48[frequency KHz] / 8[frequency KHz] = 1'440
684 // jitter = 1'440[jitter] + (abs(50[receive time ms] *
685 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'440[jitter] + 8)
686 // / 16 = 2'790
687 // final jitter: 2'790 / 16 = 174
688 EXPECT_EQ(GetJitter(*statistics), 174U);
689 }
690
TEST(ReviseJitterTest,FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged)691 TEST(ReviseJitterTest,
692 FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) {
693 SimulatedClock clock(0);
694 std::unique_ptr<ReceiveStatistics> statistics =
695 ReceiveStatistics::Create(&clock);
696 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
697 /*timestamp=*/1);
698 RtpPacketReceived packet2 = MakeNextRtpPacket(
699 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
700 RtpPacketReceived packet3 = MakeNextRtpPacket(
701 packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960);
702
703 statistics->OnRtpPacket(packet1);
704 clock.AdvanceTimeMilliseconds(50);
705 statistics->OnRtpPacket(packet2);
706 clock.AdvanceTimeMilliseconds(50);
707 statistics->OnRtpPacket(packet3);
708
709 // packet1: no jitter calculation
710 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
711 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
712 // / 16 = 240
713 // packet3: revised jitter: 240 * 48[frequency KHz] / 8[frequency KHz] = 1'440
714 // jitter = 1'440[jitter] + (abs(50[receive time ms] *
715 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'440[jitter] + 8)
716 // / 16 = 2'790
717 // final jitter: 2'790 / 16 = 174
718 EXPECT_EQ(GetJitter(*statistics), 174U);
719 }
720
TEST(ReviseJitterTest,FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged)721 TEST(ReviseJitterTest,
722 FirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) {
723 SimulatedClock clock(0);
724 std::unique_ptr<ReceiveStatistics> statistics =
725 ReceiveStatistics::Create(&clock);
726 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
727 /*timestamp=*/1);
728 RtpPacketReceived packet2 = MakeNextRtpPacket(
729 packet1, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160);
730 RtpPacketReceived packet3 = MakeNextRtpPacket(
731 packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160 + 160);
732
733 statistics->OnRtpPacket(packet1);
734 clock.AdvanceTimeMilliseconds(50);
735 statistics->OnRtpPacket(packet2);
736 clock.AdvanceTimeMilliseconds(50);
737 statistics->OnRtpPacket(packet3);
738
739 // packet1: no jitter calculation
740 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
741 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
742 // / 16 = 240
743 // packet3: jitter = 240[jitter] + (abs(50[receive time ms] *
744 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 240[jitter] + 8)
745 // / 16 = 465
746 // final jitter: 465 / 16 = 29
747 EXPECT_EQ(GetJitter(*statistics), 29U);
748 }
749
TEST(ReviseJitterTest,TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged)750 TEST(ReviseJitterTest,
751 TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) {
752 SimulatedClock clock(0);
753 std::unique_ptr<ReceiveStatistics> statistics =
754 ReceiveStatistics::Create(&clock);
755 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
756 /*timestamp=*/1);
757 RtpPacketReceived packet2 = MakeNextRtpPacket(
758 packet1, /*payload_type_frequency=*/0, /*timestamp=*/1 + 160);
759 RtpPacketReceived packet3 = MakeNextRtpPacket(
760 packet2, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 160 + 960);
761 RtpPacketReceived packet4 =
762 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000,
763 /*timestamp=*/1 + 160 + 960 + 160);
764
765 statistics->OnRtpPacket(packet1);
766 clock.AdvanceTimeMilliseconds(50);
767 statistics->OnRtpPacket(packet2);
768 clock.AdvanceTimeMilliseconds(50);
769 statistics->OnRtpPacket(packet3);
770 clock.AdvanceTimeMilliseconds(50);
771 statistics->OnRtpPacket(packet4);
772
773 // packet1: no jitter calculation
774 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
775 // 0[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
776 // / 16 = 160
777 // packet3: jitter = 160[jitter] + (abs(50[receive time ms] *
778 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 160[jitter] + 8)
779 // / 16 = 1'590
780 // packet4: revised jitter: 1'590 * 8[frequency KHz] / 48[frequency KHz] = 265
781 // packet4: jitter = 265[jitter] + (abs(50[receive time ms] *
782 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 265[jitter] + 8)
783 // / 16 = 488
784 // final jitter: 488 / 16 = 30
785 EXPECT_EQ(GetJitter(*statistics), 30U);
786 }
787
TEST(ReviseJitterTest,TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged)788 TEST(ReviseJitterTest,
789 TwoFirstPacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) {
790 SimulatedClock clock(0);
791 std::unique_ptr<ReceiveStatistics> statistics =
792 ReceiveStatistics::Create(&clock);
793 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/0,
794 /*timestamp=*/1);
795 RtpPacketReceived packet2 = MakeNextRtpPacket(
796 packet1, /*payload_type_frequency=*/0, /*timestamp=*/1 + 160);
797 RtpPacketReceived packet3 = MakeNextRtpPacket(
798 packet2, /*payload_type_frequency=*/8'000, /*timestamp=*/1 + 160 + 160);
799 RtpPacketReceived packet4 =
800 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000,
801 /*timestamp=*/1 + 160 + 160 + 160);
802
803 statistics->OnRtpPacket(packet1);
804 clock.AdvanceTimeMilliseconds(50);
805 statistics->OnRtpPacket(packet2);
806 clock.AdvanceTimeMilliseconds(50);
807 statistics->OnRtpPacket(packet3);
808 clock.AdvanceTimeMilliseconds(50);
809 statistics->OnRtpPacket(packet4);
810
811 // packet1: no jitter calculation
812 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
813 // 0[frequency KHz] - 160[timestamp diff]) * 16 - 0[jitter] + 8)
814 // / 16 = 160
815 // packet3: jitter = 160[jitter] + (abs(50[receive time ms] *
816 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 160[jitter] + 8)
817 // / 16 = 390
818 // packet4: jitter = 390[jitter] + (abs(50[receive time ms] *
819 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 390[jitter] + 8)
820 // / 16 = 606
821 // final jitter: 606 / 16 = 37
822 EXPECT_EQ(GetJitter(*statistics), 37U);
823 }
824
TEST(ReviseJitterTest,MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyChanged)825 TEST(ReviseJitterTest,
826 MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyChanged) {
827 SimulatedClock clock(0);
828 std::unique_ptr<ReceiveStatistics> statistics =
829 ReceiveStatistics::Create(&clock);
830 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/48'000,
831 /*timestamp=*/1);
832 RtpPacketReceived packet2 = MakeNextRtpPacket(
833 packet1, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 960);
834 RtpPacketReceived packet3 = MakeNextRtpPacket(
835 packet2, /*payload_type_frequency=*/0, /*timestamp=*/1 + 960 + 55);
836 RtpPacketReceived packet4 =
837 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/8'000,
838 /*timestamp=*/1 + 960 + 55 + 160);
839
840 statistics->OnRtpPacket(packet1);
841 clock.AdvanceTimeMilliseconds(50);
842 statistics->OnRtpPacket(packet2);
843 clock.AdvanceTimeMilliseconds(50);
844 statistics->OnRtpPacket(packet3);
845 clock.AdvanceTimeMilliseconds(50);
846 statistics->OnRtpPacket(packet4);
847
848 // packet1: no jitter calculation
849 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
850 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 0[jitter] + 8)
851 // / 16 = 1'440
852 // packet3: jitter = 1'440[jitter] + (abs(50[receive time ms] *
853 // 0[frequency KHz] - 55[timestamp diff]) * 16 - 1'440[jitter] + 8)
854 // / 16 = 1'405
855 // packet4: revised jitter: 1'405 * 8[frequency KHz] / 48[frequency KHz] = 234
856 // jitter = 234[jitter] + (abs(50[receive time ms] *
857 // 8[frequency KHz] - 160[timestamp diff]) * 16 - 234[jitter] + 8)
858 // / 16 = 459
859 // final jitter: 459 / 16 = 28
860 EXPECT_EQ(GetJitter(*statistics), 28U);
861 }
862
TEST(ReviseJitterTest,MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged)863 TEST(ReviseJitterTest,
864 MiddlePacketPayloadTypeFrequencyIsZeroAndFrequencyNotChanged) {
865 SimulatedClock clock(0);
866 std::unique_ptr<ReceiveStatistics> statistics =
867 ReceiveStatistics::Create(&clock);
868 RtpPacketReceived packet1 = MakeRtpPacket(/*payload_type_frequency=*/48'000,
869 /*timestamp=*/1);
870 RtpPacketReceived packet2 = MakeNextRtpPacket(
871 packet1, /*payload_type_frequency=*/48'000, /*timestamp=*/1 + 960);
872 RtpPacketReceived packet3 = MakeNextRtpPacket(
873 packet2, /*payload_type_frequency=*/0, /*timestamp=*/1 + 960 + 55);
874 RtpPacketReceived packet4 =
875 MakeNextRtpPacket(packet3, /*payload_type_frequency=*/48'000,
876 /*timestamp=*/1 + 960 + 55 + 960);
877
878 statistics->OnRtpPacket(packet1);
879 clock.AdvanceTimeMilliseconds(50);
880 statistics->OnRtpPacket(packet2);
881 clock.AdvanceTimeMilliseconds(50);
882 statistics->OnRtpPacket(packet3);
883 clock.AdvanceTimeMilliseconds(50);
884 statistics->OnRtpPacket(packet4);
885
886 // packet1: no jitter calculation
887 // packet2: jitter = 0[jitter] + (abs(50[receive time ms] *
888 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 0[jitter] + 8)
889 // / 16 = 1'440
890 // packet3: jitter = 1'440[jitter] + (abs(50[receive time ms] *
891 // 0[frequency KHz] - 55[timestamp diff]) * 16 - 1'440[jitter] + 8)
892 // / 16 = 1'405
893 // packet4: jitter = 1'405[jitter] + (abs(50[receive time ms] *
894 // 48[frequency KHz] - 960[timestamp diff]) * 16 - 1'405[jitter] + 8)
895 // / 16 = 2'757
896 // final jitter: 2'757 / 16 = 172
897 EXPECT_EQ(GetJitter(*statistics), 172U);
898 }
899
900 } // namespace
901 } // namespace webrtc
902