zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Take out the RTCPSender object under test from the test fixture

Browse Source 
Intended to make it easier to write tests varying the
construction-time settings.

Bug: None
Change-Id: I397beee8f7ab48c79ecd095d7e8486f93f9d9b17
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/195544
Commit-Queue: Niels Moller <nisse@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#32727}
This commit is contained in:
Niels Möller
2020-12-01 10:44:00 +01:00
committed by Commit Bot
parent 6562109fc9
commit 582ffe27df
1 changed files with 207 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

373
modules/rtp_rtcp/source/rtcp_sender_unittest.cc
View File

@ -68,6 +68,21 @@ static const uint32_t kSenderSsrc = 0x11111111;
static const uint32_t kRemoteSsrc = 0x22222222;
static const uint32_t kStartRtpTimestamp = 0x34567;
static const uint32_t kRtpTimestamp = 0x45678;
std::unique_ptr<RTCPSender> CreateRtcpSender(
const RtpRtcpInterface::Configuration& config,
bool init_timestamps = true) {
auto rtcp_sender = std::make_unique<RTCPSender>(config);
rtcp_sender->SetRemoteSSRC(kRemoteSsrc);
if (init_timestamps) {
rtcp_sender->SetTimestampOffset(kStartRtpTimestamp);
rtcp_sender->SetLastRtpTime(kRtpTimestamp,
config.clock->TimeInMilliseconds(),
/*payload_type=*/0);
}
return rtcp_sender;
}
} // namespace
class RtcpSenderTest : public ::testing::Test {
@ -78,11 +93,6 @@ class RtcpSenderTest : public ::testing::Test {
retransmission_rate_limiter_(&clock_, 1000) {
RtpRtcpInterface::Configuration configuration = GetDefaultConfig();
rtp_rtcp_impl_.reset(new ModuleRtpRtcpImpl2(configuration));
rtcp_sender_.reset(new RTCPSender(configuration));
rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
/*payload_type=*/0);
}
RtpRtcpInterface::Configuration GetDefaultConfig() {
@ -116,37 +126,40 @@ class RtcpSenderTest : public ::testing::Test {
TestTransport test_transport_;
std::unique_ptr<ReceiveStatistics> receive_statistics_;
std::unique_ptr<ModuleRtpRtcpImpl2> rtp_rtcp_impl_;
std::unique_ptr<RTCPSender> rtcp_sender_;
RateLimiter retransmission_rate_limiter_;
};
TEST_F(RtcpSenderTest, SetRtcpStatus) {
EXPECT_EQ(RtcpMode::kOff, rtcp_sender_->Status());
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(RtcpMode::kReducedSize, rtcp_sender_->Status());
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
EXPECT_EQ(RtcpMode::kOff, rtcp_sender->Status());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(RtcpMode::kReducedSize, rtcp_sender->Status());
}
TEST_F(RtcpSenderTest, SetSendingStatus) {
EXPECT_FALSE(rtcp_sender_->Sending());
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
EXPECT_TRUE(rtcp_sender_->Sending());
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
EXPECT_FALSE(rtcp_sender->Sending());
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
EXPECT_TRUE(rtcp_sender->Sending());
}
TEST_F(RtcpSenderTest, NoPacketSentIfOff) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kOff);
EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kOff);
EXPECT_EQ(-1, rtcp_sender->SendRTCP(feedback_state(), kRtcpSr));
}
TEST_F(RtcpSenderTest, SendSr) {
const uint32_t kPacketCount = 0x12345;
const uint32_t kOctetCount = 0x23456;
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
rtcp_sender_->SetSendingStatus(feedback_state, true);
rtcp_sender->SetSendingStatus(feedback_state, true);
feedback_state.packets_sent = kPacketCount;
feedback_state.media_bytes_sent = kOctetCount;
NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state, kRtcpSr));
EXPECT_EQ(1, parser()->sender_report()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->sender_report()->sender_ssrc());
EXPECT_EQ(ntp, parser()->sender_report()->ntp());
@ -162,15 +175,16 @@ TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
const uint32_t kOctetCount = 0x23456;
const int kTimeBetweenSRsUs = 10043; // Not exact value in milliseconds.
const int kExtraPackets = 30;
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
// Make sure clock is not exactly at some milliseconds point.
clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
rtcp_sender_->SetSendingStatus(feedback_state, true);
rtcp_sender->SetSendingStatus(feedback_state, true);
feedback_state.packets_sent = kPacketCount;
feedback_state.media_bytes_sent = kOctetCount;
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state, kRtcpSr));
EXPECT_EQ(1, parser()->sender_report()->num_packets());
NtpTime ntp1 = parser()->sender_report()->ntp();
uint32_t rtp1 = parser()->sender_report()->rtp_timestamp();
@ -178,7 +192,7 @@ TEST_F(RtcpSenderTest, SendConsecutiveSrWithExactSlope) {
// Send more SRs to ensure slope is always exact for different offsets
for (int packets = 1; packets <= kExtraPackets; ++packets) {
clock_.AdvanceTimeMicroseconds(kTimeBetweenSRsUs);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state, kRtcpSr));
EXPECT_EQ(packets + 1, parser()->sender_report()->num_packets());
NtpTime ntp2 = parser()->sender_report()->ntp();
@ -197,18 +211,17 @@ TEST_F(RtcpSenderTest, DoNotSendSrBeforeRtp) {
config.outgoing_transport = &test_transport_;
config.rtcp_report_interval_ms = 1000;
config.local_media_ssrc = kSenderSsrc;
rtcp_sender_.reset(new RTCPSender(config));
rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender_->SetSendingStatus(feedback_state(), true);
auto rtcp_sender = CreateRtcpSender(config, /*init_timestamps=*/false);
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender->SetSendingStatus(feedback_state(), true);
// Sender Report shouldn't be send as an SR nor as a Report.
rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr);
rtcp_sender->SendRTCP(feedback_state(), kRtcpSr);
EXPECT_EQ(0, parser()->sender_report()->num_packets());
rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
rtcp_sender->SendRTCP(feedback_state(), kRtcpReport);
EXPECT_EQ(0, parser()->sender_report()->num_packets());
// Other packets (e.g. Pli) are allowed, even if useless.
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpPli));
EXPECT_EQ(1, parser()->pli()->num_packets());
}
@ -219,20 +232,20 @@ TEST_F(RtcpSenderTest, DoNotSendCompundBeforeRtp) {
config.outgoing_transport = &test_transport_;
config.rtcp_report_interval_ms = 1000;
config.local_media_ssrc = kSenderSsrc;
rtcp_sender_.reset(new RTCPSender(config));
rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender_->SetSendingStatus(feedback_state(), true);
auto rtcp_sender = CreateRtcpSender(config, /*init_timestamps=*/false);
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender->SetSendingStatus(feedback_state(), true);
// In compound mode no packets are allowed (e.g. Pli) because compound mode
// should start with Sender Report.
EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
EXPECT_EQ(-1, rtcp_sender->SendRTCP(feedback_state(), kRtcpPli));
EXPECT_EQ(0, parser()->pli()->num_packets());
}
TEST_F(RtcpSenderTest, SendRr) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpRr));
EXPECT_EQ(1, parser()->receiver_report()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
EXPECT_EQ(0U, parser()->receiver_report()->report_blocks().size());
@ -240,9 +253,10 @@ TEST_F(RtcpSenderTest, SendRr) {
TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
const uint16_t kSeqNum = 11111;
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
InsertIncomingPacket(kRemoteSsrc, kSeqNum);
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpRr));
EXPECT_EQ(1, parser()->receiver_report()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
ASSERT_EQ(1U, parser()->receiver_report()->report_blocks().size());
@ -255,10 +269,11 @@ TEST_F(RtcpSenderTest, SendRrWithOneReportBlock) {
TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
const uint16_t kSeqNum = 11111;
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
InsertIncomingPacket(kRemoteSsrc, kSeqNum);
InsertIncomingPacket(kRemoteSsrc + 1, kSeqNum + 1);
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr));
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpRr));
EXPECT_EQ(1, parser()->receiver_report()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->receiver_report()->sender_ssrc());
EXPECT_EQ(2U, parser()->receiver_report()->report_blocks().size());
@ -269,9 +284,10 @@ TEST_F(RtcpSenderTest, SendRrWithTwoReportBlocks) {
}
TEST_F(RtcpSenderTest, SendSdes) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SetCNAME("alice@host"));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpSdes));
EXPECT_EQ(1, parser()->sdes()->num_packets());
EXPECT_EQ(1U, parser()->sdes()->chunks().size());
EXPECT_EQ(kSenderSsrc, parser()->sdes()->chunks()[0].ssrc);
@ -279,68 +295,75 @@ TEST_F(RtcpSenderTest, SendSdes) {
}
TEST_F(RtcpSenderTest, SendSdesWithMaxChunks) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SetCNAME("alice@host"));
const char cname[] = "smith@host";
for (size_t i = 0; i < 30; ++i) {
const uint32_t csrc = 0x1234 + i;
EXPECT_EQ(0, rtcp_sender_->AddMixedCNAME(csrc, cname));
EXPECT_EQ(0, rtcp_sender->AddMixedCNAME(csrc, cname));
}
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSdes));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpSdes));
EXPECT_EQ(1, parser()->sdes()->num_packets());
EXPECT_EQ(31U, parser()->sdes()->chunks().size());
}
TEST_F(RtcpSenderTest, SdesIncludedInCompoundPacket) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SetCNAME("alice@host"));
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetCNAME("alice@host"));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->receiver_report()->num_packets());
EXPECT_EQ(1, parser()->sdes()->num_packets());
EXPECT_EQ(1U, parser()->sdes()->chunks().size());
}
TEST_F(RtcpSenderTest, SendBye) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpBye));
EXPECT_EQ(1, parser()->bye()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
}
TEST_F(RtcpSenderTest, StopSendingTriggersBye) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
EXPECT_EQ(1, parser()->bye()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->bye()->sender_ssrc());
}
TEST_F(RtcpSenderTest, SendFir) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpFir));
EXPECT_EQ(1, parser()->fir()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->fir()->sender_ssrc());
EXPECT_EQ(1U, parser()->fir()->requests().size());
EXPECT_EQ(kRemoteSsrc, parser()->fir()->requests()[0].ssrc);
uint8_t seq = parser()->fir()->requests()[0].seq_nr;
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpFir));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpFir));
EXPECT_EQ(2, parser()->fir()->num_packets());
EXPECT_EQ(seq + 1, parser()->fir()->requests()[0].seq_nr);
}
TEST_F(RtcpSenderTest, SendPli) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpPli));
EXPECT_EQ(1, parser()->pli()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->pli()->sender_ssrc());
EXPECT_EQ(kRemoteSsrc, parser()->pli()->media_ssrc());
}
TEST_F(RtcpSenderTest, SendNack) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
const uint16_t kList[] = {0, 1, 16};
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack,
ABSL_ARRAYSIZE(kList), kList));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpNack,
ABSL_ARRAYSIZE(kList), kList));
EXPECT_EQ(1, parser()->nack()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->nack()->sender_ssrc());
EXPECT_EQ(kRemoteSsrc, parser()->nack()->media_ssrc());
@ -348,14 +371,15 @@ TEST_F(RtcpSenderTest, SendNack) {
}
TEST_F(RtcpSenderTest, SendLossNotificationBufferingNotAllowed) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
constexpr uint16_t kLastDecoded = 0x1234;
constexpr uint16_t kLastReceived = 0x4321;
constexpr bool kDecodabilityFlag = true;
constexpr bool kBufferingAllowed = false;
EXPECT_EQ(rtcp_sender_->SendLossNotification(feedback_state(), kLastDecoded,
kLastReceived, kDecodabilityFlag,
kBufferingAllowed),
EXPECT_EQ(rtcp_sender->SendLossNotification(feedback_state(), kLastDecoded,
kLastReceived, kDecodabilityFlag,
kBufferingAllowed),
0);
EXPECT_EQ(parser()->processed_rtcp_packets(), 1u);
EXPECT_EQ(parser()->loss_notification()->num_packets(), 1);
@ -364,14 +388,15 @@ TEST_F(RtcpSenderTest, SendLossNotificationBufferingNotAllowed) {
}
TEST_F(RtcpSenderTest, SendLossNotificationBufferingAllowed) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
constexpr uint16_t kLastDecoded = 0x1234;
constexpr uint16_t kLastReceived = 0x4321;
constexpr bool kDecodabilityFlag = true;
constexpr bool kBufferingAllowed = true;
EXPECT_EQ(rtcp_sender_->SendLossNotification(feedback_state(), kLastDecoded,
kLastReceived, kDecodabilityFlag,
kBufferingAllowed),
EXPECT_EQ(rtcp_sender->SendLossNotification(feedback_state(), kLastDecoded,
kLastReceived, kDecodabilityFlag,
kBufferingAllowed),
0);
// No RTCP messages sent yet.
@ -379,8 +404,8 @@ TEST_F(RtcpSenderTest, SendLossNotificationBufferingAllowed) {
// Sending another messages triggers sending the LNTF messages as well.
const uint16_t kList[] = {0, 1, 16};
EXPECT_EQ(rtcp_sender_->SendRTCP(feedback_state(), kRtcpNack,
ABSL_ARRAYSIZE(kList), kList),
EXPECT_EQ(rtcp_sender->SendRTCP(feedback_state(), kRtcpNack,
ABSL_ARRAYSIZE(kList), kList),
0);
// Exactly one packet was produced, and it contained both the buffered LNTF
@ -395,9 +420,10 @@ TEST_F(RtcpSenderTest, SendLossNotificationBufferingAllowed) {
}
TEST_F(RtcpSenderTest, RembNotIncludedBeforeSet) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
rtcp_sender->SendRTCP(feedback_state(), kRtcpRr);
ASSERT_EQ(1, parser()->receiver_report()->num_packets());
EXPECT_EQ(0, parser()->remb()->num_packets());
@ -406,15 +432,16 @@ TEST_F(RtcpSenderTest, RembNotIncludedBeforeSet) {
TEST_F(RtcpSenderTest, RembNotIncludedAfterUnset) {
const int64_t kBitrate = 261011;
const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender_->SetRemb(kBitrate, kSsrcs);
rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender->SetRemb(kBitrate, kSsrcs);
rtcp_sender->SendRTCP(feedback_state(), kRtcpRr);
ASSERT_EQ(1, parser()->receiver_report()->num_packets());
EXPECT_EQ(1, parser()->remb()->num_packets());
// Turn off REMB. rtcp_sender no longer should send it.
rtcp_sender_->UnsetRemb();
rtcp_sender_->SendRTCP(feedback_state(), kRtcpRr);
rtcp_sender->UnsetRemb();
rtcp_sender->SendRTCP(feedback_state(), kRtcpRr);
ASSERT_EQ(2, parser()->receiver_report()->num_packets());
EXPECT_EQ(1, parser()->remb()->num_packets());
}
@ -422,10 +449,11 @@ TEST_F(RtcpSenderTest, RembNotIncludedAfterUnset) {
TEST_F(RtcpSenderTest, SendRemb) {
const int64_t kBitrate = 261011;
const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender_->SetRemb(kBitrate, kSsrcs);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender->SetRemb(kBitrate, kSsrcs);
rtcp_sender_->SendRTCP(feedback_state(), kRtcpRemb);
rtcp_sender->SendRTCP(feedback_state(), kRtcpRemb);
EXPECT_EQ(1, parser()->remb()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->remb()->sender_ssrc());
@ -437,25 +465,27 @@ TEST_F(RtcpSenderTest, SendRemb) {
TEST_F(RtcpSenderTest, RembIncludedInEachCompoundPacketAfterSet) {
const int kBitrate = 261011;
const std::vector<uint32_t> kSsrcs = {kRemoteSsrc, kRemoteSsrc + 1};
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender_->SetRemb(kBitrate, kSsrcs);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender->SetRemb(kBitrate, kSsrcs);
rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
rtcp_sender->SendRTCP(feedback_state(), kRtcpReport);
EXPECT_EQ(1, parser()->remb()->num_packets());
// REMB should be included in each compound packet.
rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport);
rtcp_sender->SendRTCP(feedback_state(), kRtcpReport);
EXPECT_EQ(2, parser()->remb()->num_packets());
}
TEST_F(RtcpSenderTest, SendXrWithDlrr) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
rtcp::ReceiveTimeInfo last_xr_rr;
last_xr_rr.ssrc = 0x11111111;
last_xr_rr.last_rr = 0x22222222;
last_xr_rr.delay_since_last_rr = 0x33333333;
feedback_state.last_xr_rtis.push_back(last_xr_rr);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state, kRtcpReport));
EXPECT_EQ(1, parser()->xr()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(1));
@ -467,7 +497,8 @@ TEST_F(RtcpSenderTest, SendXrWithDlrr) {
TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
const size_t kNumReceivers = 2;
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
RTCPSender::FeedbackState feedback_state = rtp_rtcp_impl_->GetFeedbackState();
for (size_t i = 0; i < kNumReceivers; ++i) {
rtcp::ReceiveTimeInfo last_xr_rr;
@ -477,7 +508,7 @@ TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
feedback_state.last_xr_rtis.push_back(last_xr_rr);
}
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state, kRtcpReport));
EXPECT_EQ(1, parser()->xr()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
ASSERT_THAT(parser()->xr()->dlrr().sub_blocks(), SizeIs(kNumReceivers));
@ -492,11 +523,12 @@ TEST_F(RtcpSenderTest, SendXrWithMultipleDlrrSubBlocks) {
}
TEST_F(RtcpSenderTest, SendXrWithRrtr) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
rtcp_sender->SendRtcpXrReceiverReferenceTime(true);
NtpTime ntp = TimeMicrosToNtp(clock_.TimeInMicroseconds());
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->xr()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
EXPECT_FALSE(parser()->xr()->dlrr());
@ -505,18 +537,20 @@ TEST_F(RtcpSenderTest, SendXrWithRrtr) {
}
TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfSending) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), true));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(true);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), true));
rtcp_sender->SendRtcpXrReceiverReferenceTime(true);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, parser()->xr()->num_packets());
}
TEST_F(RtcpSenderTest, TestNoXrRrtrSentIfNotEnabled) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state(), false));
rtcp_sender_->SendRtcpXrReceiverReferenceTime(false);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SetSendingStatus(feedback_state(), false));
rtcp_sender->SendRtcpXrReceiverReferenceTime(false);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, parser()->xr()->num_packets());
}
@ -528,11 +562,9 @@ TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
config.outgoing_transport = &test_transport_;
config.rtcp_packet_type_counter_observer = &observer;
config.rtcp_report_interval_ms = 1000;
rtcp_sender_.reset(new RTCPSender(config));
rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpPli));
auto rtcp_sender = CreateRtcpSender(config);
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpPli));
EXPECT_EQ(1, parser()->pli()->num_packets());
EXPECT_EQ(kRemoteSsrc, observer.ssrc_);
EXPECT_EQ(1U, observer.counter_.pli_packets);
@ -542,9 +574,10 @@ TEST_F(RtcpSenderTest, TestRegisterRtcpPacketTypeObserver) {
TEST_F(RtcpSenderTest, SendTmmbr) {
const unsigned int kBitrateBps = 312000;
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender_->SetTargetBitrate(kBitrateBps);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpTmmbr));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender->SetTargetBitrate(kBitrateBps);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpTmmbr));
EXPECT_EQ(1, parser()->tmmbr()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->tmmbr()->sender_ssrc());
EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
@ -554,34 +587,36 @@ TEST_F(RtcpSenderTest, SendTmmbr) {
TEST_F(RtcpSenderTest, TmmbrIncludedInCompoundPacketIfEnabled) {
const unsigned int kBitrateBps = 312000;
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_FALSE(rtcp_sender_->TMMBR());
rtcp_sender_->SetTMMBRStatus(true);
EXPECT_TRUE(rtcp_sender_->TMMBR());
rtcp_sender_->SetTargetBitrate(kBitrateBps);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_FALSE(rtcp_sender->TMMBR());
rtcp_sender->SetTMMBRStatus(true);
EXPECT_TRUE(rtcp_sender->TMMBR());
rtcp_sender->SetTargetBitrate(kBitrateBps);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->tmmbr()->num_packets());
EXPECT_EQ(1U, parser()->tmmbr()->requests().size());
// TMMBR should be included in each compound packet.
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(2, parser()->tmmbr()->num_packets());
rtcp_sender_->SetTMMBRStatus(false);
EXPECT_FALSE(rtcp_sender_->TMMBR());
rtcp_sender->SetTMMBRStatus(false);
EXPECT_FALSE(rtcp_sender->TMMBR());
}
TEST_F(RtcpSenderTest, SendTmmbn) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender_->SetSendingStatus(feedback_state(), true);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender->SetSendingStatus(feedback_state(), true);
std::vector<rtcp::TmmbItem> bounding_set;
const uint32_t kBitrateBps = 32768000;
const uint32_t kPacketOh = 40;
const uint32_t kSourceSsrc = 12345;
const rtcp::TmmbItem tmmbn(kSourceSsrc, kBitrateBps, kPacketOh);
bounding_set.push_back(tmmbn);
rtcp_sender_->SetTmmbn(bounding_set);
rtcp_sender->SetTmmbn(bounding_set);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpSr));
EXPECT_EQ(1, parser()->sender_report()->num_packets());
EXPECT_EQ(1, parser()->tmmbn()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
@ -598,11 +633,12 @@ TEST_F(RtcpSenderTest, SendTmmbn) {
// See http://code.google.com/p/webrtc/issues/detail?id=468 for one
// situation where this caused confusion.
TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender_->SetSendingStatus(feedback_state(), true);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender->SetSendingStatus(feedback_state(), true);
std::vector<rtcp::TmmbItem> bounding_set;
rtcp_sender_->SetTmmbn(bounding_set);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpSr));
rtcp_sender->SetTmmbn(bounding_set);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpSr));
EXPECT_EQ(1, parser()->sender_report()->num_packets());
EXPECT_EQ(1, parser()->tmmbn()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->tmmbn()->sender_ssrc());
@ -611,20 +647,21 @@ TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) {
TEST_F(RtcpSenderTest, SendCompoundPliRemb) {
const int kBitrate = 261011;
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
std::vector<uint32_t> ssrcs;
ssrcs.push_back(kRemoteSsrc);
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender_->SetRemb(kBitrate, ssrcs);
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender->SetRemb(kBitrate, ssrcs);
std::set<RTCPPacketType> packet_types;
packet_types.insert(kRtcpRemb);
packet_types.insert(kRtcpPli);
EXPECT_EQ(0, rtcp_sender_->SendCompoundRTCP(feedback_state(), packet_types));
EXPECT_EQ(0, rtcp_sender->SendCompoundRTCP(feedback_state(), packet_types));
EXPECT_EQ(1, parser()->remb()->num_packets());
EXPECT_EQ(1, parser()->pli()->num_packets());
}
// This test is written to verify that BYE is always the last packet
// type in a RTCP compoud packet. The rtcp_sender_ is recreated with
// type in a RTCP compoud packet. The rtcp_sender is recreated with
// mock_transport, which is used to check for whether BYE at the end
// of a RTCP compound packet.
TEST_F(RtcpSenderTest, ByeMustBeLast) {
@ -649,28 +686,28 @@ TEST_F(RtcpSenderTest, ByeMustBeLast) {
return true;
}));
// Re-configure rtcp_sender_ with mock_transport_
// Re-configure rtcp_sender with mock_transport_
RtpRtcpInterface::Configuration config;
config.clock = &clock_;
config.receive_statistics = receive_statistics_.get();
config.outgoing_transport = &mock_transport;
config.rtcp_report_interval_ms = 1000;
config.local_media_ssrc = kSenderSsrc;
rtcp_sender_.reset(new RTCPSender(config));
auto rtcp_sender = CreateRtcpSender(config);
rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
rtcp_sender_->SetTimestampOffset(kStartRtpTimestamp);
rtcp_sender_->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
/*payload_type=*/0);
rtcp_sender->SetTimestampOffset(kStartRtpTimestamp);
rtcp_sender->SetLastRtpTime(kRtpTimestamp, clock_.TimeInMilliseconds(),
/*payload_type=*/0);
// Set up REMB info to be included with BYE.
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender_->SetRemb(1234, {});
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpBye));
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
rtcp_sender->SetRemb(1234, {});
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpBye));
}
TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
const size_t kNumSpatialLayers = 2;
const size_t kNumTemporalLayers = 2;
VideoBitrateAllocation allocation;
@ -679,9 +716,9 @@ TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
for (size_t tl = 0; tl < kNumTemporalLayers; ++tl)
allocation.SetBitrate(sl, tl, start_bitrate_bps + (tl * 20000));
}
rtcp_sender_->SetVideoBitrateAllocation(allocation);
rtcp_sender->SetVideoBitrateAllocation(allocation);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_EQ(1, parser()->xr()->num_packets());
EXPECT_EQ(kSenderSsrc, parser()->xr()->sender_ssrc());
const absl::optional<rtcp::TargetBitrate>& target_bitrate =
@ -706,48 +743,50 @@ TEST_F(RtcpSenderTest, SendXrWithTargetBitrate) {
TEST_F(RtcpSenderTest, SendImmediateXrWithTargetBitrate) {
// Initialize. Send a first report right away.
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
clock_.AdvanceTimeMilliseconds(5);
// Video bitrate allocation generated, save until next time we send a report.
VideoBitrateAllocation allocation;
allocation.SetBitrate(0, 0, 100000);
rtcp_sender_->SetVideoBitrateAllocation(allocation);
rtcp_sender->SetVideoBitrateAllocation(allocation);
// First seen instance will be sent immediately.
EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
EXPECT_TRUE(rtcp_sender->TimeToSendRTCPReport(false));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
clock_.AdvanceTimeMilliseconds(5);
// Update bitrate of existing layer, does not quality for immediate sending.
allocation.SetBitrate(0, 0, 150000);
rtcp_sender_->SetVideoBitrateAllocation(allocation);
EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
rtcp_sender->SetVideoBitrateAllocation(allocation);
EXPECT_FALSE(rtcp_sender->TimeToSendRTCPReport(false));
// A new spatial layer enabled, signal this as soon as possible.
allocation.SetBitrate(1, 0, 200000);
rtcp_sender_->SetVideoBitrateAllocation(allocation);
EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
rtcp_sender->SetVideoBitrateAllocation(allocation);
EXPECT_TRUE(rtcp_sender->TimeToSendRTCPReport(false));
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
clock_.AdvanceTimeMilliseconds(5);
// Explicitly disable top layer. The same set of layers now has a bitrate
// defined, but the explicit 0 indicates shutdown. Signal immediately.
allocation.SetBitrate(1, 0, 0);
EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
rtcp_sender_->SetVideoBitrateAllocation(allocation);
EXPECT_TRUE(rtcp_sender_->TimeToSendRTCPReport(false));
EXPECT_FALSE(rtcp_sender->TimeToSendRTCPReport(false));
rtcp_sender->SetVideoBitrateAllocation(allocation);
EXPECT_TRUE(rtcp_sender->TimeToSendRTCPReport(false));
}
TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) {
// Set up and send a bitrate allocation with two layers.
rtcp_sender_->SetRTCPStatus(RtcpMode::kCompound);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kCompound);
VideoBitrateAllocation allocation;
allocation.SetBitrate(0, 0, 100000);
allocation.SetBitrate(1, 0, 200000);
rtcp_sender_->SetVideoBitrateAllocation(allocation);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
rtcp_sender->SetVideoBitrateAllocation(allocation);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
absl::optional<rtcp::TargetBitrate> target_bitrate =
parser()->xr()->target_bitrate();
ASSERT_TRUE(target_bitrate);
@ -762,8 +801,8 @@ TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) {
// Create a new allocation, where the second stream is no longer available.
VideoBitrateAllocation new_allocation;
new_allocation.SetBitrate(0, 0, 150000);
rtcp_sender_->SetVideoBitrateAllocation(new_allocation);
EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state(), kRtcpReport));
rtcp_sender->SetVideoBitrateAllocation(new_allocation);
EXPECT_EQ(0, rtcp_sender->SendRTCP(feedback_state(), kRtcpReport));
target_bitrate = parser()->xr()->target_bitrate();
ASSERT_TRUE(target_bitrate);
bitrates = target_bitrate->GetTargetBitrates();
@ -777,15 +816,17 @@ TEST_F(RtcpSenderTest, SendTargetBitrateExplicitZeroOnStreamRemoval) {
}
TEST_F(RtcpSenderTest, DoesntSchedulesInitialReportWhenSsrcSetOnConstruction) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender_->SetRemoteSSRC(kRemoteSsrc);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
rtcp_sender->SetRemoteSSRC(kRemoteSsrc);
// New report should not have been scheduled yet.
clock_.AdvanceTimeMilliseconds(100);
EXPECT_FALSE(rtcp_sender_->TimeToSendRTCPReport(false));
EXPECT_FALSE(rtcp_sender->TimeToSendRTCPReport(false));
}
TEST_F(RtcpSenderTest, SendsCombinedRtcpPacket) {
rtcp_sender_->SetRTCPStatus(RtcpMode::kReducedSize);
auto rtcp_sender = CreateRtcpSender(GetDefaultConfig());
rtcp_sender->SetRTCPStatus(RtcpMode::kReducedSize);
std::vector<std::unique_ptr<rtcp::RtcpPacket>> packets;
auto transport_feedback = std::make_unique<rtcp::TransportFeedback>();
@ -793,7 +834,7 @@ TEST_F(RtcpSenderTest, SendsCombinedRtcpPacket) {
packets.push_back(std::move(transport_feedback));
auto remote_estimate = std::make_unique<rtcp::RemoteEstimate>();
packets.push_back(std::move(remote_estimate));
rtcp_sender_->SendCombinedRtcpPacket(std::move(packets));
rtcp_sender->SendCombinedRtcpPacket(std::move(packets));
EXPECT_EQ(parser()->transport_feedback()->num_packets(), 1);
EXPECT_EQ(parser()->transport_feedback()->sender_ssrc(), kSenderSsrc);