Integrate rtcp packet class to rtcp receiver tests.
R=stefan@webrtc.org
Review URL: https://webrtc-codereview.appspot.com/11539004
git-svn-id: http://webrtc.googlecode.com/svn/trunk/webrtc@6795 4adac7df-926f-26a2-2b94-8c16560cd09d
diff --git a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
index 399c133..8443894 100644
--- a/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
+++ b/modules/rtp_rtcp/source/rtcp_receiver_unittest.cc
@@ -19,6 +19,7 @@
#include "webrtc/common_types.h"
#include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h"
#include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h"
+#include "webrtc/modules/rtp_rtcp/source/rtcp_packet.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h"
#include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
@@ -28,197 +29,6 @@
namespace { // Anonymous namespace; hide utility functions and classes.
-// A very simple packet builder class for building RTCP packets.
-class PacketBuilder {
- public:
- static const int kMaxPacketSize = 1024;
-
- struct ReportBlock {
- ReportBlock(uint32_t ssrc, uint32_t extended_max, uint8_t fraction_loss,
- uint32_t cumulative_loss, uint32_t jitter)
- : ssrc(ssrc),
- extended_max(extended_max),
- fraction_loss(fraction_loss),
- cumulative_loss(cumulative_loss),
- jitter(jitter) {}
-
- uint32_t ssrc;
- uint32_t extended_max;
- uint8_t fraction_loss;
- uint32_t cumulative_loss;
- uint32_t jitter;
- };
-
- PacketBuilder()
- : pos_(0),
- pos_of_len_(0) {
- }
-
-
- void Add8(uint8_t byte) {
- EXPECT_LT(pos_, kMaxPacketSize - 1);
- buffer_[pos_] = byte;
- ++pos_;
- }
-
- void Add16(uint16_t word) {
- Add8(word >> 8);
- Add8(word & 0xFF);
- }
-
- void Add32(uint32_t word) {
- Add8(word >> 24);
- Add8((word >> 16) & 0xFF);
- Add8((word >> 8) & 0xFF);
- Add8(word & 0xFF);
- }
-
- void Add64(uint32_t upper_half, uint32_t lower_half) {
- Add32(upper_half);
- Add32(lower_half);
- }
-
- // Set the 5-bit value in the 1st byte of the header
- // and the payload type. Set aside room for the length field,
- // and make provision for backpatching it.
- // Note: No way to set the padding bit.
- void AddRtcpHeader(int payload, int format_or_count) {
- PatchLengthField();
- Add8(0x80 | (format_or_count & 0x1F));
- Add8(payload);
- pos_of_len_ = pos_;
- Add16(0xDEAD); // Initialize length to "clearly illegal".
- }
-
- void AddTmmbrBandwidth(int mantissa, int exponent, int overhead) {
- // 6 bits exponent, 17 bits mantissa, 9 bits overhead.
- uint32_t word = 0;
- word |= (exponent << 26);
- word |= ((mantissa & 0x1FFFF) << 9);
- word |= (overhead & 0x1FF);
- Add32(word);
- }
-
- void AddSrPacket(uint32_t sender_ssrc) {
- AddRtcpHeader(200, 0);
- Add32(sender_ssrc);
- Add64(0x10203, 0x4050607); // NTP timestamp
- Add32(0x10203); // RTP timestamp
- Add32(0); // Sender's packet count
- Add32(0); // Sender's octet count
- }
-
- void AddRrPacket(uint32_t sender_ssrc, uint32_t rtp_ssrc,
- uint32_t extended_max, uint8_t fraction_loss,
- uint32_t cumulative_loss, uint32_t jitter) {
- ReportBlock report_block(rtp_ssrc, extended_max, fraction_loss,
- cumulative_loss, jitter);
- std::list<ReportBlock> report_block_vector(&report_block,
- &report_block + 1);
- AddRrPacketMultipleReportBlocks(sender_ssrc, report_block_vector);
- }
-
- void AddRrPacketMultipleReportBlocks(
- uint32_t sender_ssrc, const std::list<ReportBlock>& report_blocks) {
- AddRtcpHeader(201, report_blocks.size());
- Add32(sender_ssrc);
- for (std::list<ReportBlock>::const_iterator it = report_blocks.begin();
- it != report_blocks.end(); ++it) {
- AddReportBlock(it->ssrc, it->extended_max, it->fraction_loss,
- it->cumulative_loss, it->jitter);
- }
- }
-
- void AddReportBlock(uint32_t rtp_ssrc, uint32_t extended_max,
- uint8_t fraction_loss, uint32_t cumulative_loss,
- uint32_t jitter) {
- Add32(rtp_ssrc);
- Add32((fraction_loss << 24) + cumulative_loss);
- Add32(extended_max);
- Add32(jitter);
- Add32(0); // Last SR.
- Add32(0); // Delay since last SR.
- }
-
- void AddXrHeader(uint32_t sender_ssrc) {
- AddRtcpHeader(207, 0);
- Add32(sender_ssrc);
- }
-
- void AddXrReceiverReferenceTimeBlock(uint32_t ntp_sec, uint32_t ntp_frac) {
- Add8(4); // Block type.
- Add8(0); // Reserved.
- Add16(2); // Length.
- Add64(ntp_sec, ntp_frac); // NTP timestamp.
- }
-
- void AddXrDlrrBlock(std::vector<uint32_t>& remote_ssrc) {
- ASSERT_LT(pos_ + 4 + static_cast<int>(remote_ssrc.size())*4,
- kMaxPacketSize-1) << "Max buffer size reached.";
- Add8(5); // Block type.
- Add8(0); // Reserved.
- Add16(remote_ssrc.size() * 3); // Length.
- for (size_t i = 0; i < remote_ssrc.size(); ++i) {
- Add32(remote_ssrc.at(i)); // Receiver SSRC.
- Add32(0x10203); // Last RR.
- Add32(0x40506); // Delay since last RR.
- }
- }
-
- void AddXrUnknownBlock() {
- Add8(6); // Block type.
- Add8(0); // Reserved.
- Add16(9); // Length.
- Add32(0); // Receiver SSRC.
- Add64(0, 0); // Remaining fields (RFC 3611) are set to zero.
- Add64(0, 0);
- Add64(0, 0);
- Add64(0, 0);
- }
-
- void AddXrVoipBlock(uint32_t remote_ssrc, uint8_t loss) {
- Add8(7); // Block type.
- Add8(0); // Reserved.
- Add16(8); // Length.
- Add32(remote_ssrc); // Receiver SSRC.
- Add8(loss); // Loss rate.
- Add8(0); // Remaining statistics (RFC 3611) are set to zero.
- Add16(0);
- Add64(0, 0);
- Add64(0, 0);
- Add64(0, 0);
- }
-
- const uint8_t* packet() {
- PatchLengthField();
- return buffer_;
- }
-
- unsigned int length() {
- return pos_;
- }
- private:
- void PatchLengthField() {
- if (pos_of_len_ > 0) {
- // Backpatch the packet length. The client must have taken
- // care of proper padding to 32-bit words.
- int this_packet_length = (pos_ - pos_of_len_ - 2);
- ASSERT_EQ(0, this_packet_length % 4)
- << "Packets must be a multiple of 32 bits long"
- << " pos " << pos_ << " pos_of_len " << pos_of_len_;
- buffer_[pos_of_len_] = this_packet_length >> 10;
- buffer_[pos_of_len_+1] = (this_packet_length >> 2) & 0xFF;
- pos_of_len_ = 0;
- }
- }
-
- int pos_;
- // Where the length field of the current packet is.
- // Note that 0 is not a legal value, so is used for "uninitialized".
- int pos_of_len_;
- uint8_t buffer_[kMaxPacketSize];
-};
-
// This test transport verifies that no functions get called.
class TestTransport : public Transport,
public NullRtpData {
@@ -338,9 +148,10 @@
TEST_F(RtcpReceiverTest, InjectSrPacket) {
const uint32_t kSenderSsrc = 0x10203;
- PacketBuilder p;
- p.AddSrPacket(kSenderSsrc);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::SenderReport sr;
+ sr.From(kSenderSsrc);
+ rtcp::RawPacket p = sr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
// The parser will note the remote SSRC on a SR from other than his
// expected peer, but will not flag that he's gotten a packet.
EXPECT_EQ(kSenderSsrc, rtcp_packet_info_.remoteSSRC);
@@ -349,9 +160,10 @@
}
TEST_F(RtcpReceiverTest, XrPacketWithZeroReportBlocksIgnored) {
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
}
@@ -362,37 +174,47 @@
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
const uint8_t kLossRate = 123;
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrVoipBlock(kSourceSsrc, kLossRate);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::VoipMetric voip_metric;
+ voip_metric.To(kSourceSsrc);
+ voip_metric.LossRate(kLossRate);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithVoipMetric(&voip_metric);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
ASSERT_TRUE(rtcp_packet_info_.VoIPMetric != NULL);
EXPECT_EQ(kLossRate, rtcp_packet_info_.VoIPMetric->lossRate);
EXPECT_EQ(kRtcpXrVoipMetric, rtcp_packet_info_.rtcpPacketTypeFlags);
}
-TEST_F(RtcpReceiverTest, InjectXrReceiverReferenceTimePacket) {
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrReceiverReferenceTimeBlock(0x10203, 0x40506);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
- EXPECT_EQ(kRtcpXrReceiverReferenceTime,
- rtcp_packet_info_.rtcpPacketTypeFlags);
-}
-
-TEST_F(RtcpReceiverTest, InjectXrDlrrPacketWithNoSubBlock) {
+TEST_F(RtcpReceiverTest, XrVoipPacketNotToUsIgnored) {
const uint32_t kSourceSsrc = 0x123456;
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- std::vector<uint32_t> remote_ssrcs;
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrDlrrBlock(remote_ssrcs);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::VoipMetric voip_metric;
+ voip_metric.To(kSourceSsrc + 1);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithVoipMetric(&voip_metric);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
- EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
+}
+
+TEST_F(RtcpReceiverTest, InjectXrReceiverReferenceTimePacket) {
+ rtcp::Rrtr rrtr;
+ rrtr.WithNtpSec(0x10203);
+ rrtr.WithNtpFrac(0x40506);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithRrtr(&rrtr);
+
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
+ EXPECT_EQ(kRtcpXrReceiverReferenceTime,
+ rtcp_packet_info_.rtcpPacketTypeFlags);
}
TEST_F(RtcpReceiverTest, XrDlrrPacketNotToUsIgnored) {
@@ -400,13 +222,14 @@
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- std::vector<uint32_t> remote_ssrcs;
- remote_ssrcs.push_back(kSourceSsrc+1);
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrDlrrBlock(remote_ssrcs);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::Dlrr dlrr;
+ dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithDlrr(&dlrr);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(0U, rtcp_packet_info_.rtcpPacketTypeFlags);
EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
}
@@ -416,13 +239,14 @@
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- std::vector<uint32_t> remote_ssrcs;
- remote_ssrcs.push_back(kSourceSsrc);
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrDlrrBlock(remote_ssrcs);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::Dlrr dlrr;
+ dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithDlrr(&dlrr);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
// The parser should note the DLRR report block item, but not flag the packet
// since the RTT is not estimated.
EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
@@ -433,36 +257,39 @@
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- std::vector<uint32_t> remote_ssrcs;
- remote_ssrcs.push_back(kSourceSsrc+2);
- remote_ssrcs.push_back(kSourceSsrc+1);
- remote_ssrcs.push_back(kSourceSsrc);
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrDlrrBlock(remote_ssrcs);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::Dlrr dlrr;
+ dlrr.WithDlrrItem(kSourceSsrc + 1, 0x12345, 0x67890);
+ dlrr.WithDlrrItem(kSourceSsrc + 2, 0x12345, 0x67890);
+ dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithDlrr(&dlrr);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
// The parser should note the DLRR report block item, but not flag the packet
// since the RTT is not estimated.
EXPECT_TRUE(rtcp_packet_info_.xr_dlrr_item);
}
TEST_F(RtcpReceiverTest, InjectXrPacketWithMultipleReportBlocks) {
- const uint8_t kLossRate = 123;
const uint32_t kSourceSsrc = 0x123456;
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- std::vector<uint32_t> remote_ssrcs;
- remote_ssrcs.push_back(kSourceSsrc);
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrDlrrBlock(remote_ssrcs);
- p.AddXrVoipBlock(kSourceSsrc, kLossRate);
- p.AddXrReceiverReferenceTimeBlock(0x10203, 0x40506);
-
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::Rrtr rrtr;
+ rtcp::Dlrr dlrr;
+ dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
+ rtcp::VoipMetric metric;
+ metric.To(kSourceSsrc);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithRrtr(&rrtr);
+ xr.WithDlrr(&dlrr);
+ xr.WithVoipMetric(&metric);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime +
kRtcpXrVoipMetric),
rtcp_packet_info_.rtcpPacketTypeFlags);
@@ -472,7 +299,6 @@
}
TEST_F(RtcpReceiverTest, InjectXrPacketWithUnknownReportBlock) {
- const uint8_t kLossRate = 123;
const uint32_t kSourceSsrc = 0x123456;
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
@@ -480,16 +306,27 @@
std::vector<uint32_t> remote_ssrcs;
remote_ssrcs.push_back(kSourceSsrc);
- PacketBuilder p;
- p.AddXrHeader(0x2345);
- p.AddXrVoipBlock(kSourceSsrc, kLossRate);
- p.AddXrUnknownBlock();
- p.AddXrReceiverReferenceTimeBlock(0x10203, 0x40506);
+ rtcp::Rrtr rrtr;
+ rtcp::Dlrr dlrr;
+ dlrr.WithDlrrItem(kSourceSsrc, 0x12345, 0x67890);
+ rtcp::VoipMetric metric;
+ metric.To(kSourceSsrc);
+ rtcp::Xr xr;
+ xr.From(0x2345);
+ xr.WithRrtr(&rrtr);
+ xr.WithDlrr(&dlrr);
+ xr.WithVoipMetric(&metric);
+ rtcp::RawPacket p = xr.Build();
+ // Modify the DLRR block to have an unsupported block type, from 5 to 6.
+ uint8_t* buffer = const_cast<uint8_t*>(p.buffer());
+ EXPECT_EQ(5, buffer[20]);
+ buffer[20] = 6;
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(static_cast<unsigned int>(kRtcpXrReceiverReferenceTime +
kRtcpXrVoipMetric),
rtcp_packet_info_.rtcpPacketTypeFlags);
+ EXPECT_FALSE(rtcp_packet_info_.xr_dlrr_item);
}
TEST(RtcpUtilityTest, MidNtp) {
@@ -515,10 +352,14 @@
const uint32_t kNtpFrac = 0x40506;
const uint32_t kNtpMid = RTCPUtility::MidNtp(kNtpSec, kNtpFrac);
- PacketBuilder p;
- p.AddXrHeader(kSenderSsrc);
- p.AddXrReceiverReferenceTimeBlock(kNtpSec, kNtpFrac);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::Rrtr rrtr;
+ rrtr.WithNtpSec(kNtpSec);
+ rrtr.WithNtpFrac(kNtpFrac);
+ rtcp::Xr xr;
+ xr.From(kSenderSsrc);
+ xr.WithRrtr(&rrtr);
+ rtcp::RawPacket p = xr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(kRtcpXrReceiverReferenceTime,
rtcp_packet_info_.rtcpPacketTypeFlags);
@@ -542,7 +383,7 @@
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- uint32_t sequence_number = 1234;
+ const uint16_t kSequenceNumber = 1234;
system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs);
// No RR received, shouldn't trigger a timeout.
@@ -550,18 +391,21 @@
EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
// Add a RR and advance the clock just enough to not trigger a timeout.
- PacketBuilder p1;
- p1.AddRrPacket(kSenderSsrc, kSourceSsrc, sequence_number, 0, 0, 0);
- EXPECT_EQ(0, InjectRtcpPacket(p1.packet(), p1.length()));
+ rtcp::ReportBlock rb1;
+ rb1.To(kSourceSsrc);
+ rb1.WithExtHighestSeqNum(kSequenceNumber);
+ rtcp::ReceiverReport rr1;
+ rr1.From(kSenderSsrc);
+ rr1.WithReportBlock(&rb1);
+ rtcp::RawPacket p1 = rr1.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
system_clock_.AdvanceTimeMilliseconds(3 * kRtcpIntervalMs - 1);
EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
// Add a RR with the same extended max as the previous RR to trigger a
// sequence number timeout, but not a RR timeout.
- PacketBuilder p2;
- p2.AddRrPacket(kSenderSsrc, kSourceSsrc, sequence_number, 0, 0, 0);
- EXPECT_EQ(0, InjectRtcpPacket(p2.packet(), p2.length()));
+ EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
system_clock_.AdvanceTimeMilliseconds(2);
EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
@@ -576,18 +420,20 @@
EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
// Add a new RR with increase sequence number to reset timers.
- PacketBuilder p3;
- sequence_number++;
- p2.AddRrPacket(kSenderSsrc, kSourceSsrc, sequence_number, 0, 0, 0);
- EXPECT_EQ(0, InjectRtcpPacket(p2.packet(), p2.length()));
+ rtcp::ReportBlock rb2;
+ rb2.To(kSourceSsrc);
+ rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
+ rtcp::ReceiverReport rr2;
+ rr2.From(kSenderSsrc);
+ rr2.WithReportBlock(&rb2);
+ rtcp::RawPacket p2 = rr2.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
EXPECT_FALSE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
// Verify we can get a timeout again once we've received new RR.
system_clock_.AdvanceTimeMilliseconds(2 * kRtcpIntervalMs);
- PacketBuilder p4;
- p4.AddRrPacket(kSenderSsrc, kSourceSsrc, sequence_number, 0, 0, 0);
- EXPECT_EQ(0, InjectRtcpPacket(p4.packet(), p4.length()));
+ EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
system_clock_.AdvanceTimeMilliseconds(kRtcpIntervalMs + 1);
EXPECT_FALSE(rtcp_receiver_->RtcpRrTimeout(kRtcpIntervalMs));
EXPECT_TRUE(rtcp_receiver_->RtcpRrSequenceNumberTimeout(kRtcpIntervalMs));
@@ -602,33 +448,51 @@
TEST_F(RtcpReceiverTest, TwoReportBlocks) {
const uint32_t kSenderSsrc = 0x10203;
- const int kNumSsrcs = 2;
- const uint32_t kSourceSsrcs[kNumSsrcs] = {0x40506, 0x50607};
- uint32_t sequence_numbers[kNumSsrcs] = {10, 12423};
+ const uint32_t kSourceSsrcs[] = {0x40506, 0x50607};
+ const uint16_t kSequenceNumbers[] = {10, 12423};
+ const int kNumSsrcs = sizeof(kSourceSsrcs) / sizeof(kSourceSsrcs[0]);
std::set<uint32_t> ssrcs(kSourceSsrcs, kSourceSsrcs + kNumSsrcs);
rtcp_receiver_->SetSsrcs(kSourceSsrcs[0], ssrcs);
- PacketBuilder packet;
- std::list<PacketBuilder::ReportBlock> report_blocks;
- report_blocks.push_back(PacketBuilder::ReportBlock(
- kSourceSsrcs[0], sequence_numbers[0], 10, 5, 0));
- report_blocks.push_back(PacketBuilder::ReportBlock(
- kSourceSsrcs[1], sequence_numbers[1], 0, 0, 0));
- packet.AddRrPacketMultipleReportBlocks(kSenderSsrc, report_blocks);
- EXPECT_EQ(0, InjectRtcpPacket(packet.packet(), packet.length()));
+ rtcp::ReportBlock rb1;
+ rb1.To(kSourceSsrcs[0]);
+ rb1.WithExtHighestSeqNum(kSequenceNumbers[0]);
+ rb1.WithFractionLost(10);
+ rb1.WithCumulativeLost(5);
+
+ rtcp::ReportBlock rb2;
+ rb2.To(kSourceSsrcs[1]);
+ rb2.WithExtHighestSeqNum(kSequenceNumbers[1]);
+
+ rtcp::ReceiverReport rr1;
+ rr1.From(kSenderSsrc);
+ rr1.WithReportBlock(&rb1);
+ rr1.WithReportBlock(&rb2);
+
+ rtcp::RawPacket p1 = rr1.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(10, rtcp_packet_info_.report_blocks.front().fractionLost);
EXPECT_EQ(0, rtcp_packet_info_.report_blocks.back().fractionLost);
- PacketBuilder packet2;
- report_blocks.clear();
- report_blocks.push_back(PacketBuilder::ReportBlock(
- kSourceSsrcs[0], sequence_numbers[0], 0, 0, 0));
- report_blocks.push_back(PacketBuilder::ReportBlock(
- kSourceSsrcs[1], sequence_numbers[1], 20, 10, 0));
- packet2.AddRrPacketMultipleReportBlocks(kSenderSsrc, report_blocks);
- EXPECT_EQ(0, InjectRtcpPacket(packet2.packet(), packet2.length()));
+ rtcp::ReportBlock rb3;
+ rb3.To(kSourceSsrcs[0]);
+ rb3.WithExtHighestSeqNum(kSequenceNumbers[0]);
+
+ rtcp::ReportBlock rb4;
+ rb4.To(kSourceSsrcs[1]);
+ rb4.WithExtHighestSeqNum(kSequenceNumbers[1]);
+ rb4.WithFractionLost(20);
+ rb4.WithCumulativeLost(10);
+
+ rtcp::ReceiverReport rr2;
+ rr2.From(kSenderSsrc);
+ rr2.WithReportBlock(&rb3);
+ rr2.WithReportBlock(&rb4);
+
+ rtcp::RawPacket p2 = rr2.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
ASSERT_EQ(2u, rtcp_packet_info_.report_blocks.size());
EXPECT_EQ(0, rtcp_packet_info_.report_blocks.front().fractionLost);
EXPECT_EQ(20, rtcp_packet_info_.report_blocks.back().fractionLost);
@@ -637,98 +501,95 @@
TEST_F(RtcpReceiverTest, TmmbrPacketAccepted) {
const uint32_t kMediaFlowSsrc = 0x2040608;
const uint32_t kSenderSsrc = 0x10203;
- const uint32_t kMediaRecipientSsrc = 0x101;
std::set<uint32_t> ssrcs;
ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above.
rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
- PacketBuilder p;
- p.AddSrPacket(kSenderSsrc);
- // TMMBR packet.
- p.AddRtcpHeader(205, 3);
- p.Add32(kSenderSsrc);
- p.Add32(kMediaRecipientSsrc);
- p.Add32(kMediaFlowSsrc);
- p.AddTmmbrBandwidth(30000, 0, 0); // 30 Kbits/sec bandwidth, no overhead.
+ rtcp::Tmmbr tmmbr;
+ tmmbr.From(kSenderSsrc);
+ tmmbr.To(kMediaFlowSsrc);
+ tmmbr.WithBitrateKbps(30);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::SenderReport sr;
+ sr.From(kSenderSsrc);
+ sr.Append(&tmmbr);
+ rtcp::RawPacket p = sr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
+
EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
TMMBRSet candidate_set;
candidate_set.VerifyAndAllocateSet(1);
EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(1, 0, &candidate_set));
EXPECT_LT(0U, candidate_set.Tmmbr(0));
- EXPECT_EQ(kMediaRecipientSsrc, candidate_set.Ssrc(0));
+ EXPECT_EQ(kSenderSsrc, candidate_set.Ssrc(0));
}
TEST_F(RtcpReceiverTest, TmmbrPacketNotForUsIgnored) {
const uint32_t kMediaFlowSsrc = 0x2040608;
const uint32_t kSenderSsrc = 0x10203;
- const uint32_t kMediaRecipientSsrc = 0x101;
- const uint32_t kOtherMediaFlowSsrc = 0x9999;
- PacketBuilder p;
- p.AddSrPacket(kSenderSsrc);
- // TMMBR packet.
- p.AddRtcpHeader(205, 3);
- p.Add32(kSenderSsrc);
- p.Add32(kMediaRecipientSsrc);
- p.Add32(kOtherMediaFlowSsrc); // This SSRC is not what we're sending.
- p.AddTmmbrBandwidth(30000, 0, 0);
+ rtcp::Tmmbr tmmbr;
+ tmmbr.From(kSenderSsrc);
+ tmmbr.To(kMediaFlowSsrc + 1); // This SSRC is not what we are sending.
+ tmmbr.WithBitrateKbps(30);
+
+ rtcp::SenderReport sr;
+ sr.From(kSenderSsrc);
+ sr.Append(&tmmbr);
+ rtcp::RawPacket p = sr.Build();
std::set<uint32_t> ssrcs;
ssrcs.insert(kMediaFlowSsrc);
rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
}
TEST_F(RtcpReceiverTest, TmmbrPacketZeroRateIgnored) {
const uint32_t kMediaFlowSsrc = 0x2040608;
const uint32_t kSenderSsrc = 0x10203;
- const uint32_t kMediaRecipientSsrc = 0x101;
std::set<uint32_t> ssrcs;
ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above.
rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
- PacketBuilder p;
- p.AddSrPacket(kSenderSsrc);
- // TMMBR packet.
- p.AddRtcpHeader(205, 3);
- p.Add32(kSenderSsrc);
- p.Add32(kMediaRecipientSsrc);
- p.Add32(kMediaFlowSsrc);
- p.AddTmmbrBandwidth(0, 0, 0); // Rate zero.
+ rtcp::Tmmbr tmmbr;
+ tmmbr.From(kSenderSsrc);
+ tmmbr.To(kMediaFlowSsrc);
+ tmmbr.WithBitrateKbps(0);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::SenderReport sr;
+ sr.From(kSenderSsrc);
+ sr.Append(&tmmbr);
+ rtcp::RawPacket p = sr.Build();
+
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
EXPECT_EQ(0, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
}
TEST_F(RtcpReceiverTest, TmmbrThreeConstraintsTimeOut) {
const uint32_t kMediaFlowSsrc = 0x2040608;
const uint32_t kSenderSsrc = 0x10203;
- const uint32_t kMediaRecipientSsrc = 0x101;
std::set<uint32_t> ssrcs;
ssrcs.insert(kMediaFlowSsrc); // Matches "media source" above.
rtcp_receiver_->SetSsrcs(kMediaFlowSsrc, ssrcs);
- // Inject 3 packets "from" kMediaRecipientSsrc, Ssrc+1, Ssrc+2.
+ // Inject 3 packets "from" kSenderSsrc, kSenderSsrc+1, kSenderSsrc+2.
// The times of arrival are starttime + 0, starttime + 5 and starttime + 10.
- for (uint32_t ssrc = kMediaRecipientSsrc;
- ssrc < kMediaRecipientSsrc+3; ++ssrc) {
- PacketBuilder p;
- p.AddSrPacket(kSenderSsrc);
- // TMMBR packet.
- p.AddRtcpHeader(205, 3);
- p.Add32(kSenderSsrc);
- p.Add32(ssrc);
- p.Add32(kMediaFlowSsrc);
- p.AddTmmbrBandwidth(30000, 0, 0); // 30 Kbits/sec bandwidth, no overhead.
+ for (uint32_t ssrc = kSenderSsrc; ssrc < kSenderSsrc + 3; ++ssrc) {
+ rtcp::Tmmbr tmmbr;
+ tmmbr.From(ssrc);
+ tmmbr.To(kMediaFlowSsrc);
+ tmmbr.WithBitrateKbps(30);
- EXPECT_EQ(0, InjectRtcpPacket(p.packet(), p.length()));
+ rtcp::SenderReport sr;
+ sr.From(ssrc);
+ sr.Append(&tmmbr);
+ rtcp::RawPacket p = sr.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p.buffer(), p.buffer_length()));
// 5 seconds between each packet.
system_clock_.AdvanceTimeMilliseconds(5000);
}
- // It is now starttime+15.
+ // It is now starttime + 15.
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
TMMBRSet candidate_set;
candidate_set.VerifyAndAllocateSet(3);
@@ -739,9 +600,8 @@
system_clock_.AdvanceTimeMilliseconds(12000);
// Odd behaviour: Just counting them does not trigger the timeout.
EXPECT_EQ(3, rtcp_receiver_->TMMBRReceived(0, 0, NULL));
- // Odd behaviour: There's only one left after timeout, not 2.
- EXPECT_EQ(1, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
- EXPECT_EQ(kMediaRecipientSsrc + 2, candidate_set.Ssrc(0));
+ EXPECT_EQ(2, rtcp_receiver_->TMMBRReceived(3, 0, &candidate_set));
+ EXPECT_EQ(kSenderSsrc + 1, candidate_set.Ssrc(0));
}
TEST_F(RtcpReceiverTest, Callbacks) {
@@ -773,31 +633,48 @@
const uint32_t kSenderSsrc = 0x10203;
const uint32_t kSourceSsrc = 0x123456;
- const uint8_t fraction_loss = 3;
- const uint32_t cumulative_loss = 7;
- const uint32_t jitter = 9;
- uint32_t sequence_number = 1234;
+ const uint8_t kFractionLoss = 3;
+ const uint32_t kCumulativeLoss = 7;
+ const uint32_t kJitter = 9;
+ const uint16_t kSequenceNumber = 1234;
std::set<uint32_t> ssrcs;
ssrcs.insert(kSourceSsrc);
rtcp_receiver_->SetSsrcs(kSourceSsrc, ssrcs);
- // First packet, all numbers should just propagate
- PacketBuilder p1;
- p1.AddRrPacket(kSenderSsrc, kSourceSsrc, sequence_number,
- fraction_loss, cumulative_loss, jitter);
- EXPECT_EQ(0, InjectRtcpPacket(p1.packet(), p1.length()));
- EXPECT_TRUE(callback.Matches(kSourceSsrc, sequence_number, fraction_loss,
- cumulative_loss, jitter));
+ // First packet, all numbers should just propagate.
+ rtcp::ReportBlock rb1;
+ rb1.To(kSourceSsrc);
+ rb1.WithExtHighestSeqNum(kSequenceNumber);
+ rb1.WithFractionLost(kFractionLoss);
+ rb1.WithCumulativeLost(kCumulativeLoss);
+ rb1.WithJitter(kJitter);
+
+ rtcp::ReceiverReport rr1;
+ rr1.From(kSenderSsrc);
+ rr1.WithReportBlock(&rb1);
+ rtcp::RawPacket p1 = rr1.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p1.buffer(), p1.buffer_length()));
+ EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
+ kCumulativeLoss, kJitter));
rtcp_receiver_->RegisterRtcpStatisticsCallback(NULL);
- // Add arbitrary numbers, callback should not be called (retain old values)
- PacketBuilder p2;
- p2.AddRrPacket(kSenderSsrc, kSourceSsrc, sequence_number + 1, 42, 137, 4711);
- EXPECT_EQ(0, InjectRtcpPacket(p2.packet(), p2.length()));
- EXPECT_TRUE(callback.Matches(kSourceSsrc, sequence_number, fraction_loss,
- cumulative_loss, jitter));
+ // Add arbitrary numbers, callback should not be called (retain old values).
+ rtcp::ReportBlock rb2;
+ rb2.To(kSourceSsrc);
+ rb2.WithExtHighestSeqNum(kSequenceNumber + 1);
+ rb2.WithFractionLost(42);
+ rb2.WithCumulativeLost(137);
+ rb2.WithJitter(4711);
+
+ rtcp::ReceiverReport rr2;
+ rr2.From(kSenderSsrc);
+ rr2.WithReportBlock(&rb2);
+ rtcp::RawPacket p2 = rr2.Build();
+ EXPECT_EQ(0, InjectRtcpPacket(p2.buffer(), p2.buffer_length()));
+ EXPECT_TRUE(callback.Matches(kSourceSsrc, kSequenceNumber, kFractionLoss,
+ kCumulativeLoss, kJitter));
}
} // Anonymous namespace
