1 /*
2 * Copyright (c) 2014 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 * This file includes unit tests for the RtcpPacket.
11 */
12
13 #include "testing/gtest/include/gtest/gtest.h"
14
15 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
16 #include "webrtc/test/rtcp_packet_parser.h"
17
18 using webrtc::rtcp::App;
19 using webrtc::rtcp::Bye;
20 using webrtc::rtcp::Dlrr;
21 using webrtc::rtcp::Empty;
22 using webrtc::rtcp::Fir;
23 using webrtc::rtcp::Ij;
24 using webrtc::rtcp::Nack;
25 using webrtc::rtcp::Pli;
26 using webrtc::rtcp::Sdes;
27 using webrtc::rtcp::SenderReport;
28 using webrtc::rtcp::Sli;
29 using webrtc::rtcp::RawPacket;
30 using webrtc::rtcp::ReceiverReport;
31 using webrtc::rtcp::Remb;
32 using webrtc::rtcp::ReportBlock;
33 using webrtc::rtcp::Rpsi;
34 using webrtc::rtcp::Rrtr;
35 using webrtc::rtcp::SenderReport;
36 using webrtc::rtcp::Tmmbn;
37 using webrtc::rtcp::Tmmbr;
38 using webrtc::rtcp::VoipMetric;
39 using webrtc::rtcp::Xr;
40 using webrtc::test::RtcpPacketParser;
41
42 namespace webrtc {
43
44 const uint32_t kSenderSsrc = 0x12345678;
45 const uint32_t kRemoteSsrc = 0x23456789;
46
TEST(RtcpPacketTest,Rr)47 TEST(RtcpPacketTest, Rr) {
48 ReceiverReport rr;
49 rr.From(kSenderSsrc);
50
51 RawPacket packet = rr.Build();
52 RtcpPacketParser parser;
53 parser.Parse(packet.buffer(), packet.buffer_length());
54 EXPECT_EQ(1, parser.receiver_report()->num_packets());
55 EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
56 EXPECT_EQ(0, parser.report_block()->num_packets());
57 }
58
TEST(RtcpPacketTest,RrWithOneReportBlock)59 TEST(RtcpPacketTest, RrWithOneReportBlock) {
60 ReportBlock rb;
61 rb.To(kRemoteSsrc);
62 rb.WithFractionLost(55);
63 rb.WithCumulativeLost(0x111111);
64 rb.WithExtHighestSeqNum(0x22222222);
65 rb.WithJitter(0x33333333);
66 rb.WithLastSr(0x44444444);
67 rb.WithDelayLastSr(0x55555555);
68
69 ReceiverReport rr;
70 rr.From(kSenderSsrc);
71 rr.WithReportBlock(&rb);
72
73 RawPacket packet = rr.Build();
74 RtcpPacketParser parser;
75 parser.Parse(packet.buffer(), packet.buffer_length());
76 EXPECT_EQ(1, parser.receiver_report()->num_packets());
77 EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
78 EXPECT_EQ(1, parser.report_block()->num_packets());
79 EXPECT_EQ(kRemoteSsrc, parser.report_block()->Ssrc());
80 EXPECT_EQ(55U, parser.report_block()->FractionLost());
81 EXPECT_EQ(0x111111U, parser.report_block()->CumPacketLost());
82 EXPECT_EQ(0x22222222U, parser.report_block()->ExtHighestSeqNum());
83 EXPECT_EQ(0x33333333U, parser.report_block()->Jitter());
84 EXPECT_EQ(0x44444444U, parser.report_block()->LastSr());
85 EXPECT_EQ(0x55555555U, parser.report_block()->DelayLastSr());
86 }
87
TEST(RtcpPacketTest,RrWithTwoReportBlocks)88 TEST(RtcpPacketTest, RrWithTwoReportBlocks) {
89 ReportBlock rb1;
90 rb1.To(kRemoteSsrc);
91 ReportBlock rb2;
92 rb2.To(kRemoteSsrc + 1);
93
94 ReceiverReport rr;
95 rr.From(kSenderSsrc);
96 rr.WithReportBlock(&rb1);
97 rr.WithReportBlock(&rb2);
98
99 RawPacket packet = rr.Build();
100 RtcpPacketParser parser;
101 parser.Parse(packet.buffer(), packet.buffer_length());
102 EXPECT_EQ(1, parser.receiver_report()->num_packets());
103 EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
104 EXPECT_EQ(2, parser.report_block()->num_packets());
105 EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc));
106 EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc + 1));
107 }
108
TEST(RtcpPacketTest,Sr)109 TEST(RtcpPacketTest, Sr) {
110 SenderReport sr;
111 sr.From(kSenderSsrc);
112 sr.WithNtpSec(0x11111111);
113 sr.WithNtpFrac(0x22222222);
114 sr.WithRtpTimestamp(0x33333333);
115 sr.WithPacketCount(0x44444444);
116 sr.WithOctetCount(0x55555555);
117
118 RawPacket packet = sr.Build();
119 RtcpPacketParser parser;
120 parser.Parse(packet.buffer(), packet.buffer_length());
121
122 EXPECT_EQ(1, parser.sender_report()->num_packets());
123 EXPECT_EQ(kSenderSsrc, parser.sender_report()->Ssrc());
124 EXPECT_EQ(0x11111111U, parser.sender_report()->NtpSec());
125 EXPECT_EQ(0x22222222U, parser.sender_report()->NtpFrac());
126 EXPECT_EQ(0x33333333U, parser.sender_report()->RtpTimestamp());
127 EXPECT_EQ(0x44444444U, parser.sender_report()->PacketCount());
128 EXPECT_EQ(0x55555555U, parser.sender_report()->OctetCount());
129 EXPECT_EQ(0, parser.report_block()->num_packets());
130 }
131
TEST(RtcpPacketTest,SrWithOneReportBlock)132 TEST(RtcpPacketTest, SrWithOneReportBlock) {
133 ReportBlock rb;
134 rb.To(kRemoteSsrc);
135
136 SenderReport sr;
137 sr.From(kSenderSsrc);
138 sr.WithReportBlock(&rb);
139
140 RawPacket packet = sr.Build();
141 RtcpPacketParser parser;
142 parser.Parse(packet.buffer(), packet.buffer_length());
143 EXPECT_EQ(1, parser.sender_report()->num_packets());
144 EXPECT_EQ(kSenderSsrc, parser.sender_report()->Ssrc());
145 EXPECT_EQ(1, parser.report_block()->num_packets());
146 EXPECT_EQ(kRemoteSsrc, parser.report_block()->Ssrc());
147 }
148
TEST(RtcpPacketTest,SrWithTwoReportBlocks)149 TEST(RtcpPacketTest, SrWithTwoReportBlocks) {
150 ReportBlock rb1;
151 rb1.To(kRemoteSsrc);
152 ReportBlock rb2;
153 rb2.To(kRemoteSsrc + 1);
154
155 SenderReport sr;
156 sr.From(kSenderSsrc);
157 sr.WithReportBlock(&rb1);
158 sr.WithReportBlock(&rb2);
159
160 RawPacket packet = sr.Build();
161 RtcpPacketParser parser;
162 parser.Parse(packet.buffer(), packet.buffer_length());
163 EXPECT_EQ(1, parser.sender_report()->num_packets());
164 EXPECT_EQ(kSenderSsrc, parser.sender_report()->Ssrc());
165 EXPECT_EQ(2, parser.report_block()->num_packets());
166 EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc));
167 EXPECT_EQ(1, parser.report_blocks_per_ssrc(kRemoteSsrc + 1));
168 }
169
TEST(RtcpPacketTest,IjNoItem)170 TEST(RtcpPacketTest, IjNoItem) {
171 Ij ij;
172
173 RawPacket packet = ij.Build();
174 RtcpPacketParser parser;
175 parser.Parse(packet.buffer(), packet.buffer_length());
176 EXPECT_EQ(1, parser.ij()->num_packets());
177 EXPECT_EQ(0, parser.ij_item()->num_packets());
178 }
179
TEST(RtcpPacketTest,IjOneItem)180 TEST(RtcpPacketTest, IjOneItem) {
181 Ij ij;
182 ij.WithJitterItem(0x11111111);
183
184 RawPacket packet = ij.Build();
185 RtcpPacketParser parser;
186 parser.Parse(packet.buffer(), packet.buffer_length());
187 EXPECT_EQ(1, parser.ij()->num_packets());
188 EXPECT_EQ(1, parser.ij_item()->num_packets());
189 EXPECT_EQ(0x11111111U, parser.ij_item()->Jitter());
190 }
191
TEST(RtcpPacketTest,IjTwoItems)192 TEST(RtcpPacketTest, IjTwoItems) {
193 Ij ij;
194 ij.WithJitterItem(0x11111111);
195 ij.WithJitterItem(0x22222222);
196
197 RawPacket packet = ij.Build();
198 RtcpPacketParser parser;
199 parser.Parse(packet.buffer(), packet.buffer_length());
200 EXPECT_EQ(1, parser.ij()->num_packets());
201 EXPECT_EQ(2, parser.ij_item()->num_packets());
202 EXPECT_EQ(0x22222222U, parser.ij_item()->Jitter());
203 }
204
TEST(RtcpPacketTest,AppWithNoData)205 TEST(RtcpPacketTest, AppWithNoData) {
206 App app;
207 app.WithSubType(30);
208 uint32_t name = 'n' << 24;
209 name += 'a' << 16;
210 name += 'm' << 8;
211 name += 'e';
212 app.WithName(name);
213
214 RawPacket packet = app.Build();
215 RtcpPacketParser parser;
216 parser.Parse(packet.buffer(), packet.buffer_length());
217 EXPECT_EQ(1, parser.app()->num_packets());
218 EXPECT_EQ(30U, parser.app()->SubType());
219 EXPECT_EQ(name, parser.app()->Name());
220 EXPECT_EQ(0, parser.app_item()->num_packets());
221 }
222
TEST(RtcpPacketTest,App)223 TEST(RtcpPacketTest, App) {
224 App app;
225 app.From(kSenderSsrc);
226 app.WithSubType(30);
227 uint32_t name = 'n' << 24;
228 name += 'a' << 16;
229 name += 'm' << 8;
230 name += 'e';
231 app.WithName(name);
232 const char kData[] = {'t', 'e', 's', 't', 'd', 'a', 't', 'a'};
233 const size_t kDataLength = sizeof(kData) / sizeof(kData[0]);
234 app.WithData((const uint8_t*)kData, kDataLength);
235
236 RawPacket packet = app.Build();
237 RtcpPacketParser parser;
238 parser.Parse(packet.buffer(), packet.buffer_length());
239 EXPECT_EQ(1, parser.app()->num_packets());
240 EXPECT_EQ(30U, parser.app()->SubType());
241 EXPECT_EQ(name, parser.app()->Name());
242 EXPECT_EQ(1, parser.app_item()->num_packets());
243 EXPECT_EQ(kDataLength, parser.app_item()->DataLength());
244 EXPECT_EQ(0, strncmp(kData, (const char*)parser.app_item()->Data(),
245 parser.app_item()->DataLength()));
246 }
247
TEST(RtcpPacketTest,SdesWithOneChunk)248 TEST(RtcpPacketTest, SdesWithOneChunk) {
249 Sdes sdes;
250 sdes.WithCName(kSenderSsrc, "alice@host");
251
252 RawPacket packet = sdes.Build();
253 RtcpPacketParser parser;
254 parser.Parse(packet.buffer(), packet.buffer_length());
255 EXPECT_EQ(1, parser.sdes()->num_packets());
256 EXPECT_EQ(1, parser.sdes_chunk()->num_packets());
257 EXPECT_EQ(kSenderSsrc, parser.sdes_chunk()->Ssrc());
258 EXPECT_EQ("alice@host", parser.sdes_chunk()->Cname());
259 }
260
TEST(RtcpPacketTest,SdesWithMultipleChunks)261 TEST(RtcpPacketTest, SdesWithMultipleChunks) {
262 Sdes sdes;
263 sdes.WithCName(kSenderSsrc, "a");
264 sdes.WithCName(kSenderSsrc + 1, "ab");
265 sdes.WithCName(kSenderSsrc + 2, "abc");
266 sdes.WithCName(kSenderSsrc + 3, "abcd");
267 sdes.WithCName(kSenderSsrc + 4, "abcde");
268 sdes.WithCName(kSenderSsrc + 5, "abcdef");
269
270 RawPacket packet = sdes.Build();
271 RtcpPacketParser parser;
272 parser.Parse(packet.buffer(), packet.buffer_length());
273 EXPECT_EQ(1, parser.sdes()->num_packets());
274 EXPECT_EQ(6, parser.sdes_chunk()->num_packets());
275 EXPECT_EQ(kSenderSsrc + 5, parser.sdes_chunk()->Ssrc());
276 EXPECT_EQ("abcdef", parser.sdes_chunk()->Cname());
277 }
278
TEST(RtcpPacketTest,CnameItemWithEmptyString)279 TEST(RtcpPacketTest, CnameItemWithEmptyString) {
280 Sdes sdes;
281 sdes.WithCName(kSenderSsrc, "");
282
283 RawPacket packet = sdes.Build();
284 RtcpPacketParser parser;
285 parser.Parse(packet.buffer(), packet.buffer_length());
286 EXPECT_EQ(1, parser.sdes()->num_packets());
287 EXPECT_EQ(1, parser.sdes_chunk()->num_packets());
288 EXPECT_EQ(kSenderSsrc, parser.sdes_chunk()->Ssrc());
289 EXPECT_EQ("", parser.sdes_chunk()->Cname());
290 }
291
TEST(RtcpPacketTest,Pli)292 TEST(RtcpPacketTest, Pli) {
293 Pli pli;
294 pli.From(kSenderSsrc);
295 pli.To(kRemoteSsrc);
296
297 RawPacket packet = pli.Build();
298 RtcpPacketParser parser;
299 parser.Parse(packet.buffer(), packet.buffer_length());
300 EXPECT_EQ(1, parser.pli()->num_packets());
301 EXPECT_EQ(kSenderSsrc, parser.pli()->Ssrc());
302 EXPECT_EQ(kRemoteSsrc, parser.pli()->MediaSsrc());
303 }
304
TEST(RtcpPacketTest,Sli)305 TEST(RtcpPacketTest, Sli) {
306 const uint16_t kFirstMb = 7777;
307 const uint16_t kNumberOfMb = 6666;
308 const uint8_t kPictureId = 60;
309 Sli sli;
310 sli.From(kSenderSsrc);
311 sli.To(kRemoteSsrc);
312 sli.WithFirstMb(kFirstMb);
313 sli.WithNumberOfMb(kNumberOfMb);
314 sli.WithPictureId(kPictureId);
315
316 RawPacket packet = sli.Build();
317 RtcpPacketParser parser;
318 parser.Parse(packet.buffer(), packet.buffer_length());
319 EXPECT_EQ(1, parser.sli()->num_packets());
320 EXPECT_EQ(kSenderSsrc, parser.sli()->Ssrc());
321 EXPECT_EQ(kRemoteSsrc, parser.sli()->MediaSsrc());
322 EXPECT_EQ(1, parser.sli_item()->num_packets());
323 EXPECT_EQ(kFirstMb, parser.sli_item()->FirstMb());
324 EXPECT_EQ(kNumberOfMb, parser.sli_item()->NumberOfMb());
325 EXPECT_EQ(kPictureId, parser.sli_item()->PictureId());
326 }
327
TEST(RtcpPacketTest,Nack)328 TEST(RtcpPacketTest, Nack) {
329 Nack nack;
330 const uint16_t kList[] = {0, 1, 3, 8, 16};
331 const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
332 nack.From(kSenderSsrc);
333 nack.To(kRemoteSsrc);
334 nack.WithList(kList, kListLength);
335 RawPacket packet = nack.Build();
336 RtcpPacketParser parser;
337 parser.Parse(packet.buffer(), packet.buffer_length());
338 EXPECT_EQ(1, parser.nack()->num_packets());
339 EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
340 EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
341 EXPECT_EQ(1, parser.nack_item()->num_packets());
342 std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list();
343 EXPECT_EQ(kListLength, seqs.size());
344 for (size_t i = 0; i < kListLength; ++i) {
345 EXPECT_EQ(kList[i], seqs[i]);
346 }
347 }
348
TEST(RtcpPacketTest,NackWithWrap)349 TEST(RtcpPacketTest, NackWithWrap) {
350 Nack nack;
351 const uint16_t kList[] = {65500, 65516, 65534, 65535, 0, 1, 3, 20, 100};
352 const uint16_t kListLength = sizeof(kList) / sizeof(kList[0]);
353 nack.From(kSenderSsrc);
354 nack.To(kRemoteSsrc);
355 nack.WithList(kList, kListLength);
356 RawPacket packet = nack.Build();
357 RtcpPacketParser parser;
358 parser.Parse(packet.buffer(), packet.buffer_length());
359 EXPECT_EQ(1, parser.nack()->num_packets());
360 EXPECT_EQ(kSenderSsrc, parser.nack()->Ssrc());
361 EXPECT_EQ(kRemoteSsrc, parser.nack()->MediaSsrc());
362 EXPECT_EQ(4, parser.nack_item()->num_packets());
363 std::vector<uint16_t> seqs = parser.nack_item()->last_nack_list();
364 EXPECT_EQ(kListLength, seqs.size());
365 for (size_t i = 0; i < kListLength; ++i) {
366 EXPECT_EQ(kList[i], seqs[i]);
367 }
368 }
369
TEST(RtcpPacketTest,Rpsi)370 TEST(RtcpPacketTest, Rpsi) {
371 Rpsi rpsi;
372 // 1000001 (7 bits = 1 byte in native string).
373 const uint64_t kPictureId = 0x41;
374 const uint16_t kNumberOfValidBytes = 1;
375 rpsi.WithPayloadType(100);
376 rpsi.WithPictureId(kPictureId);
377
378 RawPacket packet = rpsi.Build();
379 RtcpPacketParser parser;
380 parser.Parse(packet.buffer(), packet.buffer_length());
381 EXPECT_EQ(100, parser.rpsi()->PayloadType());
382 EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
383 EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
384 }
385
TEST(RtcpPacketTest,RpsiWithTwoByteNativeString)386 TEST(RtcpPacketTest, RpsiWithTwoByteNativeString) {
387 Rpsi rpsi;
388 // |1 0000001 (7 bits = 1 byte in native string).
389 const uint64_t kPictureId = 0x81;
390 const uint16_t kNumberOfValidBytes = 2;
391 rpsi.WithPictureId(kPictureId);
392
393 RawPacket packet = rpsi.Build();
394 RtcpPacketParser parser;
395 parser.Parse(packet.buffer(), packet.buffer_length());
396 EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
397 EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
398 }
399
TEST(RtcpPacketTest,RpsiWithThreeByteNativeString)400 TEST(RtcpPacketTest, RpsiWithThreeByteNativeString) {
401 Rpsi rpsi;
402 // 10000|00 100000|0 1000000 (7 bits = 1 byte in native string).
403 const uint64_t kPictureId = 0x102040;
404 const uint16_t kNumberOfValidBytes = 3;
405 rpsi.WithPictureId(kPictureId);
406
407 RawPacket packet = rpsi.Build();
408 RtcpPacketParser parser;
409 parser.Parse(packet.buffer(), packet.buffer_length());
410 EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
411 EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
412 }
413
TEST(RtcpPacketTest,RpsiWithFourByteNativeString)414 TEST(RtcpPacketTest, RpsiWithFourByteNativeString) {
415 Rpsi rpsi;
416 // 1000|001 00001|01 100001|1 1000010 (7 bits = 1 byte in native string).
417 const uint64_t kPictureId = 0x84161C2;
418 const uint16_t kNumberOfValidBytes = 4;
419 rpsi.WithPictureId(kPictureId);
420
421 RawPacket packet = rpsi.Build();
422 RtcpPacketParser parser;
423 parser.Parse(packet.buffer(), packet.buffer_length());
424 EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
425 EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
426 }
427
TEST(RtcpPacketTest,RpsiWithMaxPictureId)428 TEST(RtcpPacketTest, RpsiWithMaxPictureId) {
429 Rpsi rpsi;
430 // 1 1111111| 1111111 1|111111 11|11111 111|1111 1111|111 11111|
431 // 11 111111|1 1111111 (7 bits = 1 byte in native string).
432 const uint64_t kPictureId = 0xffffffffffffffff;
433 const uint16_t kNumberOfValidBytes = 10;
434 rpsi.WithPictureId(kPictureId);
435
436 RawPacket packet = rpsi.Build();
437 RtcpPacketParser parser;
438 parser.Parse(packet.buffer(), packet.buffer_length());
439 EXPECT_EQ(kNumberOfValidBytes * 8, parser.rpsi()->NumberOfValidBits());
440 EXPECT_EQ(kPictureId, parser.rpsi()->PictureId());
441 }
442
TEST(RtcpPacketTest,Fir)443 TEST(RtcpPacketTest, Fir) {
444 Fir fir;
445 fir.From(kSenderSsrc);
446 fir.To(kRemoteSsrc);
447 fir.WithCommandSeqNum(123);
448
449 RawPacket packet = fir.Build();
450 RtcpPacketParser parser;
451 parser.Parse(packet.buffer(), packet.buffer_length());
452 EXPECT_EQ(1, parser.fir()->num_packets());
453 EXPECT_EQ(kSenderSsrc, parser.fir()->Ssrc());
454 EXPECT_EQ(1, parser.fir_item()->num_packets());
455 EXPECT_EQ(kRemoteSsrc, parser.fir_item()->Ssrc());
456 EXPECT_EQ(123U, parser.fir_item()->SeqNum());
457 }
458
TEST(RtcpPacketTest,AppendPacket)459 TEST(RtcpPacketTest, AppendPacket) {
460 Fir fir;
461 ReportBlock rb;
462 ReceiverReport rr;
463 rr.From(kSenderSsrc);
464 rr.WithReportBlock(&rb);
465 rr.Append(&fir);
466
467 RawPacket packet = rr.Build();
468 RtcpPacketParser parser;
469 parser.Parse(packet.buffer(), packet.buffer_length());
470 EXPECT_EQ(1, parser.receiver_report()->num_packets());
471 EXPECT_EQ(kSenderSsrc, parser.receiver_report()->Ssrc());
472 EXPECT_EQ(1, parser.report_block()->num_packets());
473 EXPECT_EQ(1, parser.fir()->num_packets());
474 }
475
TEST(RtcpPacketTest,AppendPacketOnEmpty)476 TEST(RtcpPacketTest, AppendPacketOnEmpty) {
477 Empty empty;
478 ReceiverReport rr;
479 rr.From(kSenderSsrc);
480 empty.Append(&rr);
481
482 RawPacket packet = empty.Build();
483 RtcpPacketParser parser;
484 parser.Parse(packet.buffer(), packet.buffer_length());
485 EXPECT_EQ(1, parser.receiver_report()->num_packets());
486 EXPECT_EQ(0, parser.report_block()->num_packets());
487 }
488
TEST(RtcpPacketTest,AppendPacketWithOwnAppendedPacket)489 TEST(RtcpPacketTest, AppendPacketWithOwnAppendedPacket) {
490 Fir fir;
491 Bye bye;
492 ReportBlock rb;
493
494 ReceiverReport rr;
495 rr.WithReportBlock(&rb);
496 rr.Append(&fir);
497
498 SenderReport sr;
499 sr.Append(&bye);
500 sr.Append(&rr);
501
502 RawPacket packet = sr.Build();
503 RtcpPacketParser parser;
504 parser.Parse(packet.buffer(), packet.buffer_length());
505 EXPECT_EQ(1, parser.sender_report()->num_packets());
506 EXPECT_EQ(1, parser.receiver_report()->num_packets());
507 EXPECT_EQ(1, parser.report_block()->num_packets());
508 EXPECT_EQ(1, parser.bye()->num_packets());
509 EXPECT_EQ(1, parser.fir()->num_packets());
510 }
511
TEST(RtcpPacketTest,Bye)512 TEST(RtcpPacketTest, Bye) {
513 Bye bye;
514 bye.From(kSenderSsrc);
515
516 RawPacket packet = bye.Build();
517 RtcpPacketParser parser;
518 parser.Parse(packet.buffer(), packet.buffer_length());
519 EXPECT_EQ(1, parser.bye()->num_packets());
520 EXPECT_EQ(kSenderSsrc, parser.bye()->Ssrc());
521 }
522
TEST(RtcpPacketTest,ByeWithCsrcs)523 TEST(RtcpPacketTest, ByeWithCsrcs) {
524 Fir fir;
525 Bye bye;
526 bye.From(kSenderSsrc);
527 bye.WithCsrc(0x22222222);
528 bye.WithCsrc(0x33333333);
529 bye.Append(&fir);
530
531 RawPacket packet = bye.Build();
532 RtcpPacketParser parser;
533 parser.Parse(packet.buffer(), packet.buffer_length());
534 EXPECT_EQ(1, parser.bye()->num_packets());
535 EXPECT_EQ(kSenderSsrc, parser.bye()->Ssrc());
536 EXPECT_EQ(1, parser.fir()->num_packets());
537 }
538
TEST(RtcpPacketTest,BuildWithInputBuffer)539 TEST(RtcpPacketTest, BuildWithInputBuffer) {
540 Fir fir;
541 ReportBlock rb;
542 ReceiverReport rr;
543 rr.From(kSenderSsrc);
544 rr.WithReportBlock(&rb);
545 rr.Append(&fir);
546
547 const size_t kRrLength = 8;
548 const size_t kReportBlockLength = 24;
549 const size_t kFirLength = 20;
550
551 size_t len = 0;
552 uint8_t packet[kRrLength + kReportBlockLength + kFirLength];
553 rr.Build(packet, &len, kRrLength + kReportBlockLength + kFirLength);
554
555 RtcpPacketParser parser;
556 parser.Parse(packet, len);
557 EXPECT_EQ(1, parser.receiver_report()->num_packets());
558 EXPECT_EQ(1, parser.report_block()->num_packets());
559 EXPECT_EQ(1, parser.fir()->num_packets());
560 }
561
TEST(RtcpPacketTest,BuildWithTooSmallBuffer)562 TEST(RtcpPacketTest, BuildWithTooSmallBuffer) {
563 ReportBlock rb;
564 ReceiverReport rr;
565 rr.From(kSenderSsrc);
566 rr.WithReportBlock(&rb);
567
568 const size_t kRrLength = 8;
569 const size_t kReportBlockLength = 24;
570
571 // No packet.
572 size_t len = 0;
573 uint8_t packet[kRrLength + kReportBlockLength - 1];
574 rr.Build(packet, &len, kRrLength + kReportBlockLength - 1);
575 EXPECT_EQ(0U, len);
576 }
577
TEST(RtcpPacketTest,BuildWithTooSmallBuffer_LastBlockFits)578 TEST(RtcpPacketTest, BuildWithTooSmallBuffer_LastBlockFits) {
579 Fir fir;
580 ReportBlock rb;
581 ReceiverReport rr;
582 rr.From(kSenderSsrc);
583 rr.WithReportBlock(&rb);
584 rr.Append(&fir);
585
586 const size_t kRrLength = 8;
587 const size_t kReportBlockLength = 24;
588
589 size_t len = 0;
590 uint8_t packet[kRrLength + kReportBlockLength - 1];
591 rr.Build(packet, &len, kRrLength + kReportBlockLength - 1);
592 RtcpPacketParser parser;
593 parser.Parse(packet, len);
594 EXPECT_EQ(0, parser.receiver_report()->num_packets());
595 EXPECT_EQ(0, parser.report_block()->num_packets());
596 EXPECT_EQ(1, parser.fir()->num_packets());
597 }
598
TEST(RtcpPacketTest,Remb)599 TEST(RtcpPacketTest, Remb) {
600 Remb remb;
601 remb.From(kSenderSsrc);
602 remb.AppliesTo(kRemoteSsrc);
603 remb.AppliesTo(kRemoteSsrc + 1);
604 remb.AppliesTo(kRemoteSsrc + 2);
605 remb.WithBitrateBps(261011);
606
607 RawPacket packet = remb.Build();
608 RtcpPacketParser parser;
609 parser.Parse(packet.buffer(), packet.buffer_length());
610 EXPECT_EQ(1, parser.psfb_app()->num_packets());
611 EXPECT_EQ(kSenderSsrc, parser.psfb_app()->Ssrc());
612 EXPECT_EQ(1, parser.remb_item()->num_packets());
613 EXPECT_EQ(261011, parser.remb_item()->last_bitrate_bps());
614 std::vector<uint32_t> ssrcs = parser.remb_item()->last_ssrc_list();
615 EXPECT_EQ(kRemoteSsrc, ssrcs[0]);
616 EXPECT_EQ(kRemoteSsrc + 1, ssrcs[1]);
617 EXPECT_EQ(kRemoteSsrc + 2, ssrcs[2]);
618 }
619
TEST(RtcpPacketTest,Tmmbr)620 TEST(RtcpPacketTest, Tmmbr) {
621 Tmmbr tmmbr;
622 tmmbr.From(kSenderSsrc);
623 tmmbr.To(kRemoteSsrc);
624 tmmbr.WithBitrateKbps(312);
625 tmmbr.WithOverhead(60);
626
627 RawPacket packet = tmmbr.Build();
628 RtcpPacketParser parser;
629 parser.Parse(packet.buffer(), packet.buffer_length());
630 EXPECT_EQ(1, parser.tmmbr()->num_packets());
631 EXPECT_EQ(kSenderSsrc, parser.tmmbr()->Ssrc());
632 EXPECT_EQ(1, parser.tmmbr_item()->num_packets());
633 EXPECT_EQ(312U, parser.tmmbr_item()->BitrateKbps());
634 EXPECT_EQ(60U, parser.tmmbr_item()->Overhead());
635 }
636
TEST(RtcpPacketTest,TmmbnWithNoItem)637 TEST(RtcpPacketTest, TmmbnWithNoItem) {
638 Tmmbn tmmbn;
639 tmmbn.From(kSenderSsrc);
640
641 RawPacket packet = tmmbn.Build();
642 RtcpPacketParser parser;
643 parser.Parse(packet.buffer(), packet.buffer_length());
644 EXPECT_EQ(1, parser.tmmbn()->num_packets());
645 EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
646 EXPECT_EQ(0, parser.tmmbn_items()->num_packets());
647 }
648
TEST(RtcpPacketTest,TmmbnWithOneItem)649 TEST(RtcpPacketTest, TmmbnWithOneItem) {
650 Tmmbn tmmbn;
651 tmmbn.From(kSenderSsrc);
652 tmmbn.WithTmmbr(kRemoteSsrc, 312, 60);
653
654 RawPacket packet = tmmbn.Build();
655 RtcpPacketParser parser;
656 parser.Parse(packet.buffer(), packet.buffer_length());
657 EXPECT_EQ(1, parser.tmmbn()->num_packets());
658 EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
659 EXPECT_EQ(1, parser.tmmbn_items()->num_packets());
660 EXPECT_EQ(kRemoteSsrc, parser.tmmbn_items()->Ssrc(0));
661 EXPECT_EQ(312U, parser.tmmbn_items()->BitrateKbps(0));
662 EXPECT_EQ(60U, parser.tmmbn_items()->Overhead(0));
663 }
664
TEST(RtcpPacketTest,TmmbnWithTwoItems)665 TEST(RtcpPacketTest, TmmbnWithTwoItems) {
666 Tmmbn tmmbn;
667 tmmbn.From(kSenderSsrc);
668 tmmbn.WithTmmbr(kRemoteSsrc, 312, 60);
669 tmmbn.WithTmmbr(kRemoteSsrc + 1, 1288, 40);
670
671 RawPacket packet = tmmbn.Build();
672 RtcpPacketParser parser;
673 parser.Parse(packet.buffer(), packet.buffer_length());
674 EXPECT_EQ(1, parser.tmmbn()->num_packets());
675 EXPECT_EQ(kSenderSsrc, parser.tmmbn()->Ssrc());
676 EXPECT_EQ(2, parser.tmmbn_items()->num_packets());
677 EXPECT_EQ(kRemoteSsrc, parser.tmmbn_items()->Ssrc(0));
678 EXPECT_EQ(312U, parser.tmmbn_items()->BitrateKbps(0));
679 EXPECT_EQ(60U, parser.tmmbn_items()->Overhead(0));
680 EXPECT_EQ(kRemoteSsrc + 1, parser.tmmbn_items()->Ssrc(1));
681 EXPECT_EQ(1288U, parser.tmmbn_items()->BitrateKbps(1));
682 EXPECT_EQ(40U, parser.tmmbn_items()->Overhead(1));
683 }
684
TEST(RtcpPacketTest,XrWithNoReportBlocks)685 TEST(RtcpPacketTest, XrWithNoReportBlocks) {
686 Xr xr;
687 xr.From(kSenderSsrc);
688
689 RawPacket packet = xr.Build();
690 RtcpPacketParser parser;
691 parser.Parse(packet.buffer(), packet.buffer_length());
692 EXPECT_EQ(1, parser.xr_header()->num_packets());
693 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
694 }
695
TEST(RtcpPacketTest,XrWithRrtr)696 TEST(RtcpPacketTest, XrWithRrtr) {
697 Rrtr rrtr;
698 rrtr.WithNtpSec(0x11111111);
699 rrtr.WithNtpFrac(0x22222222);
700 Xr xr;
701 xr.From(kSenderSsrc);
702 xr.WithRrtr(&rrtr);
703
704 RawPacket packet = xr.Build();
705 RtcpPacketParser parser;
706 parser.Parse(packet.buffer(), packet.buffer_length());
707 EXPECT_EQ(1, parser.xr_header()->num_packets());
708 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
709 EXPECT_EQ(1, parser.rrtr()->num_packets());
710 EXPECT_EQ(0x11111111U, parser.rrtr()->NtpSec());
711 EXPECT_EQ(0x22222222U, parser.rrtr()->NtpFrac());
712 }
713
TEST(RtcpPacketTest,XrWithTwoRrtrBlocks)714 TEST(RtcpPacketTest, XrWithTwoRrtrBlocks) {
715 Rrtr rrtr1;
716 rrtr1.WithNtpSec(0x11111111);
717 rrtr1.WithNtpFrac(0x22222222);
718 Rrtr rrtr2;
719 rrtr2.WithNtpSec(0x33333333);
720 rrtr2.WithNtpFrac(0x44444444);
721 Xr xr;
722 xr.From(kSenderSsrc);
723 xr.WithRrtr(&rrtr1);
724 xr.WithRrtr(&rrtr2);
725
726 RawPacket packet = xr.Build();
727 RtcpPacketParser parser;
728 parser.Parse(packet.buffer(), packet.buffer_length());
729 EXPECT_EQ(1, parser.xr_header()->num_packets());
730 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
731 EXPECT_EQ(2, parser.rrtr()->num_packets());
732 EXPECT_EQ(0x33333333U, parser.rrtr()->NtpSec());
733 EXPECT_EQ(0x44444444U, parser.rrtr()->NtpFrac());
734 }
735
TEST(RtcpPacketTest,XrWithDlrrWithOneSubBlock)736 TEST(RtcpPacketTest, XrWithDlrrWithOneSubBlock) {
737 Dlrr dlrr;
738 dlrr.WithDlrrItem(0x11111111, 0x22222222, 0x33333333);
739 Xr xr;
740 xr.From(kSenderSsrc);
741 xr.WithDlrr(&dlrr);
742
743 RawPacket packet = xr.Build();
744 RtcpPacketParser parser;
745 parser.Parse(packet.buffer(), packet.buffer_length());
746 EXPECT_EQ(1, parser.xr_header()->num_packets());
747 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
748 EXPECT_EQ(1, parser.dlrr()->num_packets());
749 EXPECT_EQ(1, parser.dlrr_items()->num_packets());
750 EXPECT_EQ(0x11111111U, parser.dlrr_items()->Ssrc(0));
751 EXPECT_EQ(0x22222222U, parser.dlrr_items()->LastRr(0));
752 EXPECT_EQ(0x33333333U, parser.dlrr_items()->DelayLastRr(0));
753 }
754
TEST(RtcpPacketTest,XrWithDlrrWithTwoSubBlocks)755 TEST(RtcpPacketTest, XrWithDlrrWithTwoSubBlocks) {
756 Dlrr dlrr;
757 dlrr.WithDlrrItem(0x11111111, 0x22222222, 0x33333333);
758 dlrr.WithDlrrItem(0x44444444, 0x55555555, 0x66666666);
759 Xr xr;
760 xr.From(kSenderSsrc);
761 xr.WithDlrr(&dlrr);
762
763 RawPacket packet = xr.Build();
764 RtcpPacketParser parser;
765 parser.Parse(packet.buffer(), packet.buffer_length());
766 EXPECT_EQ(1, parser.xr_header()->num_packets());
767 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
768 EXPECT_EQ(1, parser.dlrr()->num_packets());
769 EXPECT_EQ(2, parser.dlrr_items()->num_packets());
770 EXPECT_EQ(0x11111111U, parser.dlrr_items()->Ssrc(0));
771 EXPECT_EQ(0x22222222U, parser.dlrr_items()->LastRr(0));
772 EXPECT_EQ(0x33333333U, parser.dlrr_items()->DelayLastRr(0));
773 EXPECT_EQ(0x44444444U, parser.dlrr_items()->Ssrc(1));
774 EXPECT_EQ(0x55555555U, parser.dlrr_items()->LastRr(1));
775 EXPECT_EQ(0x66666666U, parser.dlrr_items()->DelayLastRr(1));
776 }
777
TEST(RtcpPacketTest,XrWithTwoDlrrBlocks)778 TEST(RtcpPacketTest, XrWithTwoDlrrBlocks) {
779 Dlrr dlrr1;
780 dlrr1.WithDlrrItem(0x11111111, 0x22222222, 0x33333333);
781 Dlrr dlrr2;
782 dlrr2.WithDlrrItem(0x44444444, 0x55555555, 0x66666666);
783 Xr xr;
784 xr.From(kSenderSsrc);
785 xr.WithDlrr(&dlrr1);
786 xr.WithDlrr(&dlrr2);
787
788 RawPacket packet = xr.Build();
789 RtcpPacketParser parser;
790 parser.Parse(packet.buffer(), packet.buffer_length());
791 EXPECT_EQ(1, parser.xr_header()->num_packets());
792 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
793 EXPECT_EQ(2, parser.dlrr()->num_packets());
794 EXPECT_EQ(2, parser.dlrr_items()->num_packets());
795 EXPECT_EQ(0x11111111U, parser.dlrr_items()->Ssrc(0));
796 EXPECT_EQ(0x22222222U, parser.dlrr_items()->LastRr(0));
797 EXPECT_EQ(0x33333333U, parser.dlrr_items()->DelayLastRr(0));
798 EXPECT_EQ(0x44444444U, parser.dlrr_items()->Ssrc(1));
799 EXPECT_EQ(0x55555555U, parser.dlrr_items()->LastRr(1));
800 EXPECT_EQ(0x66666666U, parser.dlrr_items()->DelayLastRr(1));
801 }
802
TEST(RtcpPacketTest,XrWithVoipMetric)803 TEST(RtcpPacketTest, XrWithVoipMetric) {
804 VoipMetric metric;
805 metric.To(kRemoteSsrc);
806 metric.LossRate(1);
807 metric.DiscardRate(2);
808 metric.BurstDensity(3);
809 metric.GapDensity(4);
810 metric.BurstDuration(0x1111);
811 metric.GapDuration(0x2222);
812 metric.RoundTripDelay(0x3333);
813 metric.EndSystemDelay(0x4444);
814 metric.SignalLevel(5);
815 metric.NoiseLevel(6);
816 metric.Rerl(7);
817 metric.Gmin(8);
818 metric.Rfactor(9);
819 metric.ExtRfactor(10);
820 metric.MosLq(11);
821 metric.MosCq(12);
822 metric.RxConfig(13);
823 metric.JbNominal(0x5555);
824 metric.JbMax(0x6666);
825 metric.JbAbsMax(0x7777);
826
827 Xr xr;
828 xr.From(kSenderSsrc);
829 xr.WithVoipMetric(&metric);
830
831 RawPacket packet = xr.Build();
832 RtcpPacketParser parser;
833 parser.Parse(packet.buffer(), packet.buffer_length());
834 EXPECT_EQ(1, parser.xr_header()->num_packets());
835 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
836 EXPECT_EQ(1, parser.voip_metric()->num_packets());
837 EXPECT_EQ(kRemoteSsrc, parser.voip_metric()->Ssrc());
838 EXPECT_EQ(1, parser.voip_metric()->LossRate());
839 EXPECT_EQ(2, parser.voip_metric()->DiscardRate());
840 EXPECT_EQ(3, parser.voip_metric()->BurstDensity());
841 EXPECT_EQ(4, parser.voip_metric()->GapDensity());
842 EXPECT_EQ(0x1111, parser.voip_metric()->BurstDuration());
843 EXPECT_EQ(0x2222, parser.voip_metric()->GapDuration());
844 EXPECT_EQ(0x3333, parser.voip_metric()->RoundTripDelay());
845 EXPECT_EQ(0x4444, parser.voip_metric()->EndSystemDelay());
846 EXPECT_EQ(5, parser.voip_metric()->SignalLevel());
847 EXPECT_EQ(6, parser.voip_metric()->NoiseLevel());
848 EXPECT_EQ(7, parser.voip_metric()->Rerl());
849 EXPECT_EQ(8, parser.voip_metric()->Gmin());
850 EXPECT_EQ(9, parser.voip_metric()->Rfactor());
851 EXPECT_EQ(10, parser.voip_metric()->ExtRfactor());
852 EXPECT_EQ(11, parser.voip_metric()->MosLq());
853 EXPECT_EQ(12, parser.voip_metric()->MosCq());
854 EXPECT_EQ(13, parser.voip_metric()->RxConfig());
855 EXPECT_EQ(0x5555, parser.voip_metric()->JbNominal());
856 EXPECT_EQ(0x6666, parser.voip_metric()->JbMax());
857 EXPECT_EQ(0x7777, parser.voip_metric()->JbAbsMax());
858 }
859
TEST(RtcpPacketTest,XrWithMultipleReportBlocks)860 TEST(RtcpPacketTest, XrWithMultipleReportBlocks) {
861 Rrtr rrtr;
862 Dlrr dlrr;
863 dlrr.WithDlrrItem(1, 2, 3);
864 VoipMetric metric;
865 Xr xr;
866 xr.From(kSenderSsrc);
867 xr.WithRrtr(&rrtr);
868 xr.WithDlrr(&dlrr);
869 xr.WithVoipMetric(&metric);
870
871 RawPacket packet = xr.Build();
872 RtcpPacketParser parser;
873 parser.Parse(packet.buffer(), packet.buffer_length());
874 EXPECT_EQ(1, parser.xr_header()->num_packets());
875 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
876 EXPECT_EQ(1, parser.rrtr()->num_packets());
877 EXPECT_EQ(1, parser.dlrr()->num_packets());
878 EXPECT_EQ(1, parser.dlrr_items()->num_packets());
879 EXPECT_EQ(1, parser.voip_metric()->num_packets());
880 }
881
TEST(RtcpPacketTest,DlrrWithoutItemNotIncludedInPacket)882 TEST(RtcpPacketTest, DlrrWithoutItemNotIncludedInPacket) {
883 Rrtr rrtr;
884 Dlrr dlrr;
885 VoipMetric metric;
886 Xr xr;
887 xr.From(kSenderSsrc);
888 xr.WithRrtr(&rrtr);
889 xr.WithDlrr(&dlrr);
890 xr.WithVoipMetric(&metric);
891
892 RawPacket packet = xr.Build();
893 RtcpPacketParser parser;
894 parser.Parse(packet.buffer(), packet.buffer_length());
895 EXPECT_EQ(1, parser.xr_header()->num_packets());
896 EXPECT_EQ(kSenderSsrc, parser.xr_header()->Ssrc());
897 EXPECT_EQ(1, parser.rrtr()->num_packets());
898 EXPECT_EQ(0, parser.dlrr()->num_packets());
899 EXPECT_EQ(1, parser.voip_metric()->num_packets());
900 }
901 } // namespace webrtc
902