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

Remove unused members in rtp_rtcp tests and make some members const.

Browse Source 
Bug: none
Change-Id: I5f92899742406157d94de235e7c1a50755b3ac61
Reviewed-on: https://webrtc-review.googlesource.com/92393
Commit-Queue: Åsa Persson <asapersson@webrtc.org>
Reviewed-by: Rasmus Brandt <brandtr@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24303}
This commit is contained in:
Åsa Persson
2018-08-16 09:13:28 +02:00
committed by Commit Bot
parent b889a20968
commit 315ce5b308
4 changed files with 101 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
modules/rtp_rtcp/test/testAPI/test_api.cc
View File

@ -82,44 +82,34 @@ class RtpRtcpAPITest : public ::testing::Test {
protected: protected:
RtpRtcpAPITest() RtpRtcpAPITest()
: fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) { : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {
test_csrcs_.push_back(1234);
test_csrcs_.push_back(2345);
test_ssrc_ = 3456;
test_timestamp_ = 4567;
test_sequence_number_ = 2345;
} }
~RtpRtcpAPITest() override = default; ~RtpRtcpAPITest() override = default;
const uint32_t initial_ssrc = 8888;
void SetUp() override { void SetUp() override {
const uint32_t kInitialSsrc = 8888;
RtpRtcp::Configuration configuration; RtpRtcp::Configuration configuration;
configuration.audio = true; configuration.audio = true;
configuration.clock = &fake_clock_; configuration.clock = &fake_clock_;
configuration.outgoing_transport = &null_transport_; configuration.outgoing_transport = &null_transport_;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
module_.reset(RtpRtcp::CreateRtpRtcp(configuration)); module_.reset(RtpRtcp::CreateRtpRtcp(configuration));
module_->SetSSRC(initial_ssrc); module_->SetSSRC(kInitialSsrc);
rtp_payload_registry_.reset(new RTPPayloadRegistry());
} }
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
std::unique_ptr<RtpRtcp> module_; std::unique_ptr<RtpRtcp> module_;
uint32_t test_ssrc_;
uint32_t test_timestamp_;
uint16_t test_sequence_number_;
std::vector<uint32_t> test_csrcs_;
SimulatedClock fake_clock_; SimulatedClock fake_clock_;
test::NullTransport null_transport_; test::NullTransport null_transport_;
RateLimiter retransmission_rate_limiter_; RateLimiter retransmission_rate_limiter_;
}; };
TEST_F(RtpRtcpAPITest, Basic) { TEST_F(RtpRtcpAPITest, Basic) {
module_->SetSequenceNumber(test_sequence_number_); const uint16_t kSequenceNumber = 2345;
EXPECT_EQ(test_sequence_number_, module_->SequenceNumber()); module_->SetSequenceNumber(kSequenceNumber);
EXPECT_EQ(kSequenceNumber, module_->SequenceNumber());
module_->SetStartTimestamp(test_timestamp_); const uint32_t kTimestamp = 4567;
EXPECT_EQ(test_timestamp_, module_->StartTimestamp()); module_->SetStartTimestamp(kTimestamp);
EXPECT_EQ(kTimestamp, module_->StartTimestamp());
EXPECT_FALSE(module_->Sending()); EXPECT_FALSE(module_->Sending());
EXPECT_EQ(0, module_->SetSendingStatus(true)); EXPECT_EQ(0, module_->SetSendingStatus(true));
@ -132,8 +122,9 @@ TEST_F(RtpRtcpAPITest, PacketSize) {
} }
TEST_F(RtpRtcpAPITest, SSRC) { TEST_F(RtpRtcpAPITest, SSRC) {
module_->SetSSRC(test_ssrc_); const uint32_t kSsrc = 3456;
EXPECT_EQ(test_ssrc_, module_->SSRC()); module_->SetSSRC(kSsrc);
EXPECT_EQ(kSsrc, module_->SSRC());
} }
TEST_F(RtpRtcpAPITest, RTCP) { TEST_F(RtpRtcpAPITest, RTCP) {

75
modules/rtp_rtcp/test/testAPI/test_api_audio.cc
View File

@ -28,6 +28,8 @@ const uint32_t kTestRate = 64000u;
const uint8_t kTestPayload[] = {'t', 'e', 's', 't'}; const uint8_t kTestPayload[] = {'t', 'e', 's', 't'};
const uint8_t kPcmuPayloadType = 96; const uint8_t kPcmuPayloadType = 96;
const uint8_t kDtmfPayloadType = 97; const uint8_t kDtmfPayloadType = 97;
const uint32_t kSsrc = 3456;
const uint32_t kTimestamp = 4567;
struct CngCodecSpec { struct CngCodecSpec {
int payload_type; int payload_type;
@ -86,43 +88,34 @@ class VerifyingAudioReceiver : public RtpData {
class RtpRtcpAudioTest : public ::testing::Test { class RtpRtcpAudioTest : public ::testing::Test {
protected: protected:
RtpRtcpAudioTest() RtpRtcpAudioTest()
: fake_clock(123456), retransmission_rate_limiter_(&fake_clock, 1000) { : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {}
test_CSRC[0] = 1234;
test_CSRC[2] = 2345;
test_ssrc = 3456;
test_timestamp = 4567;
test_sequence_number = 2345;
}
~RtpRtcpAudioTest() override = default; ~RtpRtcpAudioTest() override = default;
void SetUp() override { void SetUp() override {
receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock)); receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock_));
receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock)); receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock_));
rtp_payload_registry1_.reset(new RTPPayloadRegistry());
rtp_payload_registry2_.reset(new RTPPayloadRegistry());
RtpRtcp::Configuration configuration; RtpRtcp::Configuration configuration;
configuration.audio = true; configuration.audio = true;
configuration.clock = &fake_clock; configuration.clock = &fake_clock_;
configuration.receive_statistics = receive_statistics1_.get(); configuration.receive_statistics = receive_statistics1_.get();
configuration.outgoing_transport = &transport1; configuration.outgoing_transport = &transport1;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
module1.reset(RtpRtcp::CreateRtpRtcp(configuration)); module1.reset(RtpRtcp::CreateRtpRtcp(configuration));
rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver( rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver(
&fake_clock, &data_receiver1, rtp_payload_registry1_.get())); &fake_clock_, &data_receiver1, &rtp_payload_registry1_));
configuration.receive_statistics = receive_statistics2_.get(); configuration.receive_statistics = receive_statistics2_.get();
configuration.outgoing_transport = &transport2; configuration.outgoing_transport = &transport2;
module2.reset(RtpRtcp::CreateRtpRtcp(configuration)); module2.reset(RtpRtcp::CreateRtpRtcp(configuration));
rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver( rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver(
&fake_clock, &data_receiver2, rtp_payload_registry2_.get())); &fake_clock_, &data_receiver2, &rtp_payload_registry2_));
transport1.SetSendModule(module2.get(), rtp_payload_registry2_.get(), transport1.SetSendModule(module2.get(), &rtp_payload_registry2_,
rtp_receiver2_.get(), receive_statistics2_.get()); rtp_receiver2_.get(), receive_statistics2_.get());
transport2.SetSendModule(module1.get(), rtp_payload_registry1_.get(), transport2.SetSendModule(module1.get(), &rtp_payload_registry1_,
rtp_receiver1_.get(), receive_statistics1_.get()); rtp_receiver1_.get(), receive_statistics1_.get());
} }
@ -139,25 +132,21 @@ class RtpRtcpAudioTest : public ::testing::Test {
VerifyingAudioReceiver data_receiver2; VerifyingAudioReceiver data_receiver2;
std::unique_ptr<ReceiveStatistics> receive_statistics1_; std::unique_ptr<ReceiveStatistics> receive_statistics1_;
std::unique_ptr<ReceiveStatistics> receive_statistics2_; std::unique_ptr<ReceiveStatistics> receive_statistics2_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry1_; RTPPayloadRegistry rtp_payload_registry1_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry2_; RTPPayloadRegistry rtp_payload_registry2_;
std::unique_ptr<RtpReceiver> rtp_receiver1_; std::unique_ptr<RtpReceiver> rtp_receiver1_;
std::unique_ptr<RtpReceiver> rtp_receiver2_; std::unique_ptr<RtpReceiver> rtp_receiver2_;
std::unique_ptr<RtpRtcp> module1; std::unique_ptr<RtpRtcp> module1;
std::unique_ptr<RtpRtcp> module2; std::unique_ptr<RtpRtcp> module2;
LoopBackTransport transport1; LoopBackTransport transport1;
LoopBackTransport transport2; LoopBackTransport transport2;
uint32_t test_ssrc; SimulatedClock fake_clock_;
uint32_t test_timestamp;
uint16_t test_sequence_number;
uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
RateLimiter retransmission_rate_limiter_; RateLimiter retransmission_rate_limiter_;
}; };
TEST_F(RtpRtcpAudioTest, Basic) { TEST_F(RtpRtcpAudioTest, Basic) {
module1->SetSSRC(test_ssrc); module1->SetSSRC(kSsrc);
module1->SetStartTimestamp(test_timestamp); module1->SetStartTimestamp(kTimestamp);
// Test detection at the end of a DTMF tone. // Test detection at the end of a DTMF tone.
// EXPECT_EQ(0, module2->SetTelephoneEventForwardToDecoder(true)); // EXPECT_EQ(0, module2->SetTelephoneEventForwardToDecoder(true));
@ -183,13 +172,13 @@ TEST_F(RtpRtcpAudioTest, Basic) {
kPcmuPayloadType, 0, -1, kTestPayload, kPcmuPayloadType, 0, -1, kTestPayload,
4, nullptr, nullptr, nullptr)); 4, nullptr, nullptr, nullptr));
EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC()); EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
uint32_t timestamp; uint32_t timestamp;
int64_t receive_time_ms; int64_t receive_time_ms;
EXPECT_TRUE( EXPECT_TRUE(
rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms)); rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
EXPECT_EQ(test_timestamp, timestamp); EXPECT_EQ(kTimestamp, timestamp);
EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms); EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
} }
TEST_F(RtpRtcpAudioTest, DTMF) { TEST_F(RtpRtcpAudioTest, DTMF) {
@ -200,8 +189,8 @@ TEST_F(RtpRtcpAudioTest, DTMF) {
memcpy(voice_codec.plname, "PCMU", 5); memcpy(voice_codec.plname, "PCMU", 5);
RegisterPayload(voice_codec); RegisterPayload(voice_codec);
module1->SetSSRC(test_ssrc); module1->SetSSRC(kSsrc);
module1->SetStartTimestamp(test_timestamp); module1->SetStartTimestamp(kTimestamp);
EXPECT_EQ(0, module1->SetSendingStatus(true)); EXPECT_EQ(0, module1->SetSendingStatus(true));
// Prepare for DTMF. // Prepare for DTMF.
@ -228,7 +217,7 @@ TEST_F(RtpRtcpAudioTest, DTMF) {
EXPECT_TRUE(module1->SendOutgoingData( EXPECT_TRUE(module1->SendOutgoingData(
webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1, webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
kTestPayload, 4, nullptr, nullptr, nullptr)); kTestPayload, 4, nullptr, nullptr, nullptr));
fake_clock.AdvanceTimeMilliseconds(20); fake_clock_.AdvanceTimeMilliseconds(20);
module1->Process(); module1->Process();
} }
EXPECT_EQ(0, module1->SendTelephoneEventOutband(32, 9000, 10)); EXPECT_EQ(0, module1->SendTelephoneEventOutband(32, 9000, 10));
@ -237,14 +226,14 @@ TEST_F(RtpRtcpAudioTest, DTMF) {
EXPECT_TRUE(module1->SendOutgoingData( EXPECT_TRUE(module1->SendOutgoingData(
webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1, webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
kTestPayload, 4, nullptr, nullptr, nullptr)); kTestPayload, 4, nullptr, nullptr, nullptr));
fake_clock.AdvanceTimeMilliseconds(20); fake_clock_.AdvanceTimeMilliseconds(20);
module1->Process(); module1->Process();
} }
} }
TEST_F(RtpRtcpAudioTest, ComfortNoise) { TEST_F(RtpRtcpAudioTest, ComfortNoise) {
module1->SetSSRC(test_ssrc); module1->SetSSRC(kSsrc);
module1->SetStartTimestamp(test_timestamp); module1->SetStartTimestamp(kTimestamp);
EXPECT_EQ(0, module1->SetSendingStatus(true)); EXPECT_EQ(0, module1->SetSendingStatus(true));
@ -273,25 +262,25 @@ TEST_F(RtpRtcpAudioTest, ComfortNoise) {
webrtc::kAudioFrameSpeech, kPcmuPayloadType, in_timestamp, -1, webrtc::kAudioFrameSpeech, kPcmuPayloadType, in_timestamp, -1,
kTestPayload, 4, nullptr, nullptr, nullptr)); kTestPayload, 4, nullptr, nullptr, nullptr));
EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC()); EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
EXPECT_TRUE( EXPECT_TRUE(
rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms)); rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
EXPECT_EQ(test_timestamp + in_timestamp, timestamp); EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms); EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
in_timestamp += 10; in_timestamp += 10;
fake_clock.AdvanceTimeMilliseconds(20); fake_clock_.AdvanceTimeMilliseconds(20);
EXPECT_TRUE(module1->SendOutgoingData(webrtc::kAudioFrameCN, c.payload_type, EXPECT_TRUE(module1->SendOutgoingData(webrtc::kAudioFrameCN, c.payload_type,
in_timestamp, -1, kTestPayload, 1, in_timestamp, -1, kTestPayload, 1,
nullptr, nullptr, nullptr)); nullptr, nullptr, nullptr));
EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC()); EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
EXPECT_TRUE( EXPECT_TRUE(
rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms)); rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
EXPECT_EQ(test_timestamp + in_timestamp, timestamp); EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms); EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
in_timestamp += 10; in_timestamp += 10;
fake_clock.AdvanceTimeMilliseconds(20); fake_clock_.AdvanceTimeMilliseconds(20);
} }
} }

111
modules/rtp_rtcp/test/testAPI/test_api_rtcp.cc
View File

@ -25,83 +25,66 @@
namespace webrtc { namespace webrtc {
namespace { namespace {
const uint16_t kSequenceNumber = 2345;
const uint32_t kSsrc = 3456;
const uint32_t kTimestamp = 4567;
class RtcpCallback : public RtcpIntraFrameObserver { class RtcpCallback : public RtcpIntraFrameObserver {
public: public:
void SetModule(RtpRtcp* module) { _rtpRtcpModule = module; }
virtual void OnRTCPPacketTimeout(const int32_t id) {}
virtual void OnLipSyncUpdate(const int32_t id,
const int32_t audioVideoOffset) {}
void OnReceivedIntraFrameRequest(uint32_t ssrc) override {} void OnReceivedIntraFrameRequest(uint32_t ssrc) override {}
private:
RtpRtcp* _rtpRtcpModule;
}; };
class RtpRtcpRtcpTest : public ::testing::Test { class RtpRtcpRtcpTest : public ::testing::Test {
protected: protected:
RtpRtcpRtcpTest() RtpRtcpRtcpTest()
: fake_clock(123456), retransmission_rate_limiter_(&fake_clock, 1000) { : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {}
test_csrcs.push_back(1234);
test_csrcs.push_back(2345);
test_ssrc = 3456;
test_timestamp = 4567;
test_sequence_number = 2345;
}
~RtpRtcpRtcpTest() override = default; ~RtpRtcpRtcpTest() override = default;
void SetUp() override { void SetUp() override {
receiver = new TestRtpReceiver(); receiver = new TestRtpReceiver();
transport1 = new LoopBackTransport(); transport1 = new LoopBackTransport();
transport2 = new LoopBackTransport(); transport2 = new LoopBackTransport();
myRTCPFeedback1 = new RtcpCallback();
myRTCPFeedback2 = new RtcpCallback();
receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock)); receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock_));
receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock)); receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock_));
RtpRtcp::Configuration configuration; RtpRtcp::Configuration configuration;
configuration.audio = true; configuration.audio = true;
configuration.clock = &fake_clock; configuration.clock = &fake_clock_;
configuration.receive_statistics = receive_statistics1_.get(); configuration.receive_statistics = receive_statistics1_.get();
configuration.outgoing_transport = transport1; configuration.outgoing_transport = transport1;
configuration.intra_frame_callback = myRTCPFeedback1; configuration.intra_frame_callback = &rtcp_callback1_;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_payload_registry1_.reset(new RTPPayloadRegistry());
rtp_payload_registry2_.reset(new RTPPayloadRegistry());
module1 = RtpRtcp::CreateRtpRtcp(configuration); module1 = RtpRtcp::CreateRtpRtcp(configuration);
rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver( rtp_receiver1_.reset(RtpReceiver::CreateAudioReceiver(
&fake_clock, receiver, rtp_payload_registry1_.get())); &fake_clock_, receiver, &rtp_payload_registry1_));
configuration.receive_statistics = receive_statistics2_.get(); configuration.receive_statistics = receive_statistics2_.get();
configuration.outgoing_transport = transport2; configuration.outgoing_transport = transport2;
configuration.intra_frame_callback = myRTCPFeedback2; configuration.intra_frame_callback = &rtcp_callback2_;
module2 = RtpRtcp::CreateRtpRtcp(configuration); module2 = RtpRtcp::CreateRtpRtcp(configuration);
rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver( rtp_receiver2_.reset(RtpReceiver::CreateAudioReceiver(
&fake_clock, receiver, rtp_payload_registry2_.get())); &fake_clock_, receiver, &rtp_payload_registry2_));
transport1->SetSendModule(module2, rtp_payload_registry2_.get(), transport1->SetSendModule(module2, &rtp_payload_registry2_,
rtp_receiver2_.get(), receive_statistics2_.get()); rtp_receiver2_.get(), receive_statistics2_.get());
transport2->SetSendModule(module1, rtp_payload_registry1_.get(), transport2->SetSendModule(module1, &rtp_payload_registry1_,
rtp_receiver1_.get(), receive_statistics1_.get()); rtp_receiver1_.get(), receive_statistics1_.get());
myRTCPFeedback1->SetModule(module1);
myRTCPFeedback2->SetModule(module2);
module1->SetRTCPStatus(RtcpMode::kCompound); module1->SetRTCPStatus(RtcpMode::kCompound);
module2->SetRTCPStatus(RtcpMode::kCompound); module2->SetRTCPStatus(RtcpMode::kCompound);
module2->SetSSRC(test_ssrc + 1); module2->SetSSRC(kSsrc + 1);
module2->SetRemoteSSRC(test_ssrc); module2->SetRemoteSSRC(kSsrc);
module1->SetSSRC(test_ssrc); module1->SetSSRC(kSsrc);
module1->SetSequenceNumber(test_sequence_number); module1->SetSequenceNumber(kSequenceNumber);
module1->SetStartTimestamp(test_timestamp); module1->SetStartTimestamp(kTimestamp);
module1->SetCsrcs(test_csrcs); module1->SetCsrcs(kCsrcs);
EXPECT_EQ(0, module1->SetCNAME("john.doe@test.test")); EXPECT_EQ(0, module1->SetCNAME("john.doe@test.test"));
EXPECT_EQ(0, module1->SetSendingStatus(true)); EXPECT_EQ(0, module1->SetSendingStatus(true));
@ -121,7 +104,7 @@ class RtpRtcpRtcpTest : public ::testing::Test {
// We need to send one RTP packet to get the RTCP packet to be accepted by // We need to send one RTP packet to get the RTCP packet to be accepted by
// the receiving module. // the receiving module.
// send RTP packet with the data "testtest" // Send RTP packet with the data "testtest".
const uint8_t test[9] = "testtest"; const uint8_t test[9] = "testtest";
EXPECT_EQ(true, EXPECT_EQ(true,
module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96, 0, -1, module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96, 0, -1,
@ -131,17 +114,17 @@ class RtpRtcpRtcpTest : public ::testing::Test {
void TearDown() override { void TearDown() override {
delete module1; delete module1;
delete module2; delete module2;
delete myRTCPFeedback1;
delete myRTCPFeedback2;
delete transport1; delete transport1;
delete transport2; delete transport2;
delete receiver; delete receiver;
} }
RtcpCallback rtcp_callback1_;
RtcpCallback rtcp_callback2_;
RTPPayloadRegistry rtp_payload_registry1_;
RTPPayloadRegistry rtp_payload_registry2_;
std::unique_ptr<ReceiveStatistics> receive_statistics1_; std::unique_ptr<ReceiveStatistics> receive_statistics1_;
std::unique_ptr<ReceiveStatistics> receive_statistics2_; std::unique_ptr<ReceiveStatistics> receive_statistics2_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry1_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry2_;
std::unique_ptr<RtpReceiver> rtp_receiver1_; std::unique_ptr<RtpReceiver> rtp_receiver1_;
std::unique_ptr<RtpReceiver> rtp_receiver2_; std::unique_ptr<RtpReceiver> rtp_receiver2_;
RtpRtcp* module1; RtpRtcp* module1;
@ -149,30 +132,25 @@ class RtpRtcpRtcpTest : public ::testing::Test {
TestRtpReceiver* receiver; TestRtpReceiver* receiver;
LoopBackTransport* transport1; LoopBackTransport* transport1;
LoopBackTransport* transport2; LoopBackTransport* transport2;
RtcpCallback* myRTCPFeedback1;
RtcpCallback* myRTCPFeedback2;
uint32_t test_ssrc; const std::vector<uint32_t> kCsrcs = {1234, 2345};
uint32_t test_timestamp; SimulatedClock fake_clock_;
uint16_t test_sequence_number;
std::vector<uint32_t> test_csrcs;
SimulatedClock fake_clock;
RateLimiter retransmission_rate_limiter_; RateLimiter retransmission_rate_limiter_;
}; };
TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) { TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
// Set cname of mixed. // Set cname of mixed.
EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[0], "john@192.168.0.1")); EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[0], "john@192.168.0.1"));
EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[1], "jane@192.168.0.2")); EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[1], "jane@192.168.0.2"));
EXPECT_EQ(-1, module1->RemoveMixedCNAME(test_csrcs[0] + 1)); EXPECT_EQ(-1, module1->RemoveMixedCNAME(kCsrcs[0] + 1));
EXPECT_EQ(0, module1->RemoveMixedCNAME(test_csrcs[1])); EXPECT_EQ(0, module1->RemoveMixedCNAME(kCsrcs[1]));
EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[1], "jane@192.168.0.2")); EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[1], "jane@192.168.0.2"));
// send RTCP packet, triggered by timer // Send RTCP packet, triggered by timer.
fake_clock.AdvanceTimeMilliseconds(7500); fake_clock_.AdvanceTimeMilliseconds(7500);
module1->Process(); module1->Process();
fake_clock.AdvanceTimeMilliseconds(100); fake_clock_.AdvanceTimeMilliseconds(100);
module2->Process(); module2->Process();
char cName[RTCP_CNAME_SIZE]; char cName[RTCP_CNAME_SIZE];
@ -182,15 +160,15 @@ TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
EXPECT_EQ(0, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName)); EXPECT_EQ(0, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName));
EXPECT_EQ(0, strncmp(cName, "john.doe@test.test", RTCP_CNAME_SIZE)); EXPECT_EQ(0, strncmp(cName, "john.doe@test.test", RTCP_CNAME_SIZE));
EXPECT_EQ(0, module2->RemoteCNAME(test_csrcs[0], cName)); EXPECT_EQ(0, module2->RemoteCNAME(kCsrcs[0], cName));
EXPECT_EQ(0, strncmp(cName, "john@192.168.0.1", RTCP_CNAME_SIZE)); EXPECT_EQ(0, strncmp(cName, "john@192.168.0.1", RTCP_CNAME_SIZE));
EXPECT_EQ(0, module2->RemoteCNAME(test_csrcs[1], cName)); EXPECT_EQ(0, module2->RemoteCNAME(kCsrcs[1], cName));
EXPECT_EQ(0, strncmp(cName, "jane@192.168.0.2", RTCP_CNAME_SIZE)); EXPECT_EQ(0, strncmp(cName, "jane@192.168.0.2", RTCP_CNAME_SIZE));
EXPECT_EQ(0, module1->SetSendingStatus(false)); EXPECT_EQ(0, module1->SetSendingStatus(false));
// Test that BYE clears the CNAME // Test that BYE clears the CNAME.
EXPECT_EQ(-1, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName)); EXPECT_EQ(-1, module2->RemoteCNAME(rtp_receiver2_->SSRC(), cName));
} }
@ -200,23 +178,22 @@ TEST_F(RtpRtcpRtcpTest, RemoteRTCPStatRemote) {
EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks)); EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks));
EXPECT_EQ(0u, report_blocks.size()); EXPECT_EQ(0u, report_blocks.size());
// send RTCP packet, triggered by timer // Send RTCP packet, triggered by timer.
fake_clock.AdvanceTimeMilliseconds(7500); fake_clock_.AdvanceTimeMilliseconds(7500);
module1->Process(); module1->Process();
fake_clock.AdvanceTimeMilliseconds(100); fake_clock_.AdvanceTimeMilliseconds(100);
module2->Process(); module2->Process();
EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks)); EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks));
ASSERT_EQ(1u, report_blocks.size()); ASSERT_EQ(1u, report_blocks.size());
// |test_ssrc+1| is the SSRC of module2 that send the report. // |kSsrc+1| is the SSRC of module2 that send the report.
EXPECT_EQ(test_ssrc + 1, report_blocks[0].sender_ssrc); EXPECT_EQ(kSsrc + 1, report_blocks[0].sender_ssrc);
EXPECT_EQ(test_ssrc, report_blocks[0].source_ssrc); EXPECT_EQ(kSsrc, report_blocks[0].source_ssrc);
EXPECT_EQ(0, report_blocks[0].packets_lost); EXPECT_EQ(0, report_blocks[0].packets_lost);
EXPECT_LT(0u, report_blocks[0].delay_since_last_sender_report); EXPECT_LT(0u, report_blocks[0].delay_since_last_sender_report);
EXPECT_EQ(test_sequence_number, EXPECT_EQ(kSequenceNumber, report_blocks[0].extended_highest_sequence_number);
report_blocks[0].extended_highest_sequence_number);
EXPECT_EQ(0u, report_blocks[0].fraction_lost); EXPECT_EQ(0u, report_blocks[0].fraction_lost);
} }

37
modules/rtp_rtcp/test/testAPI/test_api_video.cc
View File

@ -12,7 +12,6 @@
#include <algorithm> #include <algorithm>
#include <memory> #include <memory>
#include <vector>
#include "api/video_codecs/video_codec.h" #include "api/video_codecs/video_codec.h"
#include "modules/rtp_rtcp/include/rtp_payload_registry.h" #include "modules/rtp_rtcp/include/rtp_payload_registry.h"
@ -25,7 +24,7 @@
#include "test/gtest.h" #include "test/gtest.h"
namespace { namespace {
const uint32_t kSsrc = 3456;
const unsigned char kPayloadType = 100; const unsigned char kPayloadType = 100;
}; };
@ -34,29 +33,25 @@ namespace webrtc {
class RtpRtcpVideoTest : public ::testing::Test { class RtpRtcpVideoTest : public ::testing::Test {
protected: protected:
RtpRtcpVideoTest() RtpRtcpVideoTest()
: test_ssrc_(3456), : fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {}
test_timestamp_(4567),
test_sequence_number_(2345),
fake_clock(123456),
retransmission_rate_limiter_(&fake_clock, 1000) {}
~RtpRtcpVideoTest() override = default; ~RtpRtcpVideoTest() override = default;
void SetUp() override { void SetUp() override {
transport_ = new LoopBackTransport(); transport_ = new LoopBackTransport();
receiver_ = new TestRtpReceiver(); receiver_ = new TestRtpReceiver();
receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock)); receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock_));
RtpRtcp::Configuration configuration; RtpRtcp::Configuration configuration;
configuration.audio = false; configuration.audio = false;
configuration.clock = &fake_clock; configuration.clock = &fake_clock_;
configuration.outgoing_transport = transport_; configuration.outgoing_transport = transport_;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_; configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
video_module_ = RtpRtcp::CreateRtpRtcp(configuration); video_module_ = RtpRtcp::CreateRtpRtcp(configuration);
rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver( rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
&fake_clock, receiver_, &rtp_payload_registry_)); &fake_clock_, receiver_, &rtp_payload_registry_));
video_module_->SetRTCPStatus(RtcpMode::kCompound); video_module_->SetRTCPStatus(RtcpMode::kCompound);
video_module_->SetSSRC(test_ssrc_); video_module_->SetSSRC(kSsrc);
video_module_->SetStorePacketsStatus(true, 600); video_module_->SetStorePacketsStatus(true, 600);
EXPECT_EQ(0, video_module_->SetSendingStatus(true)); EXPECT_EQ(0, video_module_->SetSendingStatus(true));
@ -78,14 +73,14 @@ class RtpRtcpVideoTest : public ::testing::Test {
} }
} }
size_t BuildRTPheader(uint8_t* dataBuffer, size_t BuildRTPheader(uint8_t* buffer,
uint32_t timestamp, uint32_t timestamp,
uint32_t sequence_number) { uint32_t sequence_number) {
dataBuffer[0] = static_cast<uint8_t>(0x80); // version 2 buffer[0] = static_cast<uint8_t>(0x80); // version 2
dataBuffer[1] = static_cast<uint8_t>(kPayloadType); buffer[1] = static_cast<uint8_t>(kPayloadType);
ByteWriter<uint16_t>::WriteBigEndian(dataBuffer + 2, sequence_number); ByteWriter<uint16_t>::WriteBigEndian(buffer + 2, sequence_number);
ByteWriter<uint32_t>::WriteBigEndian(dataBuffer + 4, timestamp); ByteWriter<uint32_t>::WriteBigEndian(buffer + 4, timestamp);
ByteWriter<uint32_t>::WriteBigEndian(dataBuffer + 8, 0x1234); // SSRC. ByteWriter<uint32_t>::WriteBigEndian(buffer + 8, 0x1234); // SSRC.
size_t rtpHeaderLength = 12; size_t rtpHeaderLength = 12;
return rtpHeaderLength; return rtpHeaderLength;
} }
@ -122,19 +117,15 @@ class RtpRtcpVideoTest : public ::testing::Test {
delete receiver_; delete receiver_;
} }
int test_id_;
std::unique_ptr<ReceiveStatistics> receive_statistics_; std::unique_ptr<ReceiveStatistics> receive_statistics_;
RTPPayloadRegistry rtp_payload_registry_; RTPPayloadRegistry rtp_payload_registry_;
std::unique_ptr<RtpReceiver> rtp_receiver_; std::unique_ptr<RtpReceiver> rtp_receiver_;
RtpRtcp* video_module_; RtpRtcp* video_module_;
LoopBackTransport* transport_; LoopBackTransport* transport_;
TestRtpReceiver* receiver_; TestRtpReceiver* receiver_;
uint32_t test_ssrc_;
uint32_t test_timestamp_;
uint16_t test_sequence_number_;
uint8_t video_frame_[65000]; uint8_t video_frame_[65000];
size_t payload_data_length_; size_t payload_data_length_;
SimulatedClock fake_clock; SimulatedClock fake_clock_;
RateLimiter retransmission_rate_limiter_; RateLimiter retransmission_rate_limiter_;
}; };
@ -174,7 +165,7 @@ TEST_F(RtpRtcpVideoTest, PaddingOnlyFrames) {
EXPECT_EQ(payload_length, receiver_->rtp_header().header.paddingLength); EXPECT_EQ(payload_length, receiver_->rtp_header().header.paddingLength);
} }
timestamp += 3000; timestamp += 3000;
fake_clock.AdvanceTimeMilliseconds(33); fake_clock_.AdvanceTimeMilliseconds(33);
} }
} }