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:
RtpRtcpAPITest()
: 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;
const uint32_t initial_ssrc = 8888;
void SetUp() override {
const uint32_t kInitialSsrc = 8888;
RtpRtcp::Configuration configuration;
configuration.audio = true;
configuration.clock = &fake_clock_;
configuration.outgoing_transport = &null_transport_;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
module_.reset(RtpRtcp::CreateRtpRtcp(configuration));
module_->SetSSRC(initial_ssrc);
rtp_payload_registry_.reset(new RTPPayloadRegistry());
module_->SetSSRC(kInitialSsrc);
}
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry_;
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_;
test::NullTransport null_transport_;
RateLimiter retransmission_rate_limiter_;
};
TEST_F(RtpRtcpAPITest, Basic) {
module_->SetSequenceNumber(test_sequence_number_);
EXPECT_EQ(test_sequence_number_, module_->SequenceNumber());
const uint16_t kSequenceNumber = 2345;
module_->SetSequenceNumber(kSequenceNumber);
EXPECT_EQ(kSequenceNumber, module_->SequenceNumber());
module_->SetStartTimestamp(test_timestamp_);
EXPECT_EQ(test_timestamp_, module_->StartTimestamp());
const uint32_t kTimestamp = 4567;
module_->SetStartTimestamp(kTimestamp);
EXPECT_EQ(kTimestamp, module_->StartTimestamp());
EXPECT_FALSE(module_->Sending());
EXPECT_EQ(0, module_->SetSendingStatus(true));
@ -132,8 +122,9 @@ TEST_F(RtpRtcpAPITest, PacketSize) {
}
TEST_F(RtpRtcpAPITest, SSRC) {
module_->SetSSRC(test_ssrc_);
EXPECT_EQ(test_ssrc_, module_->SSRC());
const uint32_t kSsrc = 3456;
module_->SetSSRC(kSsrc);
EXPECT_EQ(kSsrc, module_->SSRC());
}
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 kPcmuPayloadType = 96;
const uint8_t kDtmfPayloadType = 97;
const uint32_t kSsrc = 3456;
const uint32_t kTimestamp = 4567;
struct CngCodecSpec {
int payload_type;
@ -86,43 +88,34 @@ class VerifyingAudioReceiver : public RtpData {
class RtpRtcpAudioTest : public ::testing::Test {
protected:
RtpRtcpAudioTest()
: 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;
}
: fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {}
~RtpRtcpAudioTest() override = default;
void SetUp() override {
receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock));
receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock));
rtp_payload_registry1_.reset(new RTPPayloadRegistry());
rtp_payload_registry2_.reset(new RTPPayloadRegistry());
receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock_));
receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock_));
RtpRtcp::Configuration configuration;
configuration.audio = true;
configuration.clock = &fake_clock;
configuration.clock = &fake_clock_;
configuration.receive_statistics = receive_statistics1_.get();
configuration.outgoing_transport = &transport1;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
module1.reset(RtpRtcp::CreateRtpRtcp(configuration));
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.outgoing_transport = &transport2;
module2.reset(RtpRtcp::CreateRtpRtcp(configuration));
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());
transport2.SetSendModule(module1.get(), rtp_payload_registry1_.get(),
transport2.SetSendModule(module1.get(), &rtp_payload_registry1_,
rtp_receiver1_.get(), receive_statistics1_.get());
}
@ -139,25 +132,21 @@ class RtpRtcpAudioTest : public ::testing::Test {
VerifyingAudioReceiver data_receiver2;
std::unique_ptr<ReceiveStatistics> receive_statistics1_;
std::unique_ptr<ReceiveStatistics> receive_statistics2_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry1_;
std::unique_ptr<RTPPayloadRegistry> rtp_payload_registry2_;
RTPPayloadRegistry rtp_payload_registry1_;
RTPPayloadRegistry rtp_payload_registry2_;
std::unique_ptr<RtpReceiver> rtp_receiver1_;
std::unique_ptr<RtpReceiver> rtp_receiver2_;
std::unique_ptr<RtpRtcp> module1;
std::unique_ptr<RtpRtcp> module2;
LoopBackTransport transport1;
LoopBackTransport transport2;
uint32_t test_ssrc;
uint32_t test_timestamp;
uint16_t test_sequence_number;
uint32_t test_CSRC[webrtc::kRtpCsrcSize];
SimulatedClock fake_clock;
SimulatedClock fake_clock_;
RateLimiter retransmission_rate_limiter_;
};
TEST_F(RtpRtcpAudioTest, Basic) {
module1->SetSSRC(test_ssrc);
module1->SetStartTimestamp(test_timestamp);
module1->SetSSRC(kSsrc);
module1->SetStartTimestamp(kTimestamp);
// Test detection at the end of a DTMF tone.
// EXPECT_EQ(0, module2->SetTelephoneEventForwardToDecoder(true));
@ -183,13 +172,13 @@ TEST_F(RtpRtcpAudioTest, Basic) {
kPcmuPayloadType, 0, -1, kTestPayload,
4, nullptr, nullptr, nullptr));
EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC());
EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
uint32_t timestamp;
int64_t receive_time_ms;
EXPECT_TRUE(
rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
EXPECT_EQ(test_timestamp, timestamp);
EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms);
EXPECT_EQ(kTimestamp, timestamp);
EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
}
TEST_F(RtpRtcpAudioTest, DTMF) {
@ -200,8 +189,8 @@ TEST_F(RtpRtcpAudioTest, DTMF) {
memcpy(voice_codec.plname, "PCMU", 5);
RegisterPayload(voice_codec);
module1->SetSSRC(test_ssrc);
module1->SetStartTimestamp(test_timestamp);
module1->SetSSRC(kSsrc);
module1->SetStartTimestamp(kTimestamp);
EXPECT_EQ(0, module1->SetSendingStatus(true));
// Prepare for DTMF.
@ -228,7 +217,7 @@ TEST_F(RtpRtcpAudioTest, DTMF) {
EXPECT_TRUE(module1->SendOutgoingData(
webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
kTestPayload, 4, nullptr, nullptr, nullptr));
fake_clock.AdvanceTimeMilliseconds(20);
fake_clock_.AdvanceTimeMilliseconds(20);
module1->Process();
}
EXPECT_EQ(0, module1->SendTelephoneEventOutband(32, 9000, 10));
@ -237,14 +226,14 @@ TEST_F(RtpRtcpAudioTest, DTMF) {
EXPECT_TRUE(module1->SendOutgoingData(
webrtc::kAudioFrameSpeech, kPcmuPayloadType, timeStamp, -1,
kTestPayload, 4, nullptr, nullptr, nullptr));
fake_clock.AdvanceTimeMilliseconds(20);
fake_clock_.AdvanceTimeMilliseconds(20);
module1->Process();
}
}
TEST_F(RtpRtcpAudioTest, ComfortNoise) {
module1->SetSSRC(test_ssrc);
module1->SetStartTimestamp(test_timestamp);
module1->SetSSRC(kSsrc);
module1->SetStartTimestamp(kTimestamp);
EXPECT_EQ(0, module1->SetSendingStatus(true));
@ -273,25 +262,25 @@ TEST_F(RtpRtcpAudioTest, ComfortNoise) {
webrtc::kAudioFrameSpeech, kPcmuPayloadType, in_timestamp, -1,
kTestPayload, 4, nullptr, nullptr, nullptr));
EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC());
EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
EXPECT_TRUE(
rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
EXPECT_EQ(test_timestamp + in_timestamp, timestamp);
EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms);
EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
in_timestamp += 10;
fake_clock.AdvanceTimeMilliseconds(20);
fake_clock_.AdvanceTimeMilliseconds(20);
EXPECT_TRUE(module1->SendOutgoingData(webrtc::kAudioFrameCN, c.payload_type,
in_timestamp, -1, kTestPayload, 1,
nullptr, nullptr, nullptr));
EXPECT_EQ(test_ssrc, rtp_receiver2_->SSRC());
EXPECT_EQ(kSsrc, rtp_receiver2_->SSRC());
EXPECT_TRUE(
rtp_receiver2_->GetLatestTimestamps(&timestamp, &receive_time_ms));
EXPECT_EQ(test_timestamp + in_timestamp, timestamp);
EXPECT_EQ(fake_clock.TimeInMilliseconds(), receive_time_ms);
EXPECT_EQ(kTimestamp + in_timestamp, timestamp);
EXPECT_EQ(fake_clock_.TimeInMilliseconds(), receive_time_ms);
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 {
const uint16_t kSequenceNumber = 2345;
const uint32_t kSsrc = 3456;
const uint32_t kTimestamp = 4567;
class RtcpCallback : public RtcpIntraFrameObserver {
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 {}
private:
RtpRtcp* _rtpRtcpModule;
};
class RtpRtcpRtcpTest : public ::testing::Test {
protected:
RtpRtcpRtcpTest()
: 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;
}
: fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {}
~RtpRtcpRtcpTest() override = default;
void SetUp() override {
receiver = new TestRtpReceiver();
transport1 = new LoopBackTransport();
transport2 = new LoopBackTransport();
myRTCPFeedback1 = new RtcpCallback();
myRTCPFeedback2 = new RtcpCallback();
receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock));
receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock));
receive_statistics1_.reset(ReceiveStatistics::Create(&fake_clock_));
receive_statistics2_.reset(ReceiveStatistics::Create(&fake_clock_));
RtpRtcp::Configuration configuration;
configuration.audio = true;
configuration.clock = &fake_clock;
configuration.clock = &fake_clock_;
configuration.receive_statistics = receive_statistics1_.get();
configuration.outgoing_transport = transport1;
configuration.intra_frame_callback = myRTCPFeedback1;
configuration.intra_frame_callback = &rtcp_callback1_;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_payload_registry1_.reset(new RTPPayloadRegistry());
rtp_payload_registry2_.reset(new RTPPayloadRegistry());
module1 = RtpRtcp::CreateRtpRtcp(configuration);
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.outgoing_transport = transport2;
configuration.intra_frame_callback = myRTCPFeedback2;
configuration.intra_frame_callback = &rtcp_callback2_;
module2 = RtpRtcp::CreateRtpRtcp(configuration);
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());
transport2->SetSendModule(module1, rtp_payload_registry1_.get(),
transport2->SetSendModule(module1, &rtp_payload_registry1_,
rtp_receiver1_.get(), receive_statistics1_.get());
myRTCPFeedback1->SetModule(module1);
myRTCPFeedback2->SetModule(module2);
module1->SetRTCPStatus(RtcpMode::kCompound);
module2->SetRTCPStatus(RtcpMode::kCompound);
module2->SetSSRC(test_ssrc + 1);
module2->SetRemoteSSRC(test_ssrc);
module1->SetSSRC(test_ssrc);
module1->SetSequenceNumber(test_sequence_number);
module1->SetStartTimestamp(test_timestamp);
module2->SetSSRC(kSsrc + 1);
module2->SetRemoteSSRC(kSsrc);
module1->SetSSRC(kSsrc);
module1->SetSequenceNumber(kSequenceNumber);
module1->SetStartTimestamp(kTimestamp);
module1->SetCsrcs(test_csrcs);
module1->SetCsrcs(kCsrcs);
EXPECT_EQ(0, module1->SetCNAME("john.doe@test.test"));
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
// the receiving module.
// send RTP packet with the data "testtest"
// Send RTP packet with the data "testtest".
const uint8_t test[9] = "testtest";
EXPECT_EQ(true,
module1->SendOutgoingData(webrtc::kAudioFrameSpeech, 96, 0, -1,
@ -131,17 +114,17 @@ class RtpRtcpRtcpTest : public ::testing::Test {
void TearDown() override {
delete module1;
delete module2;
delete myRTCPFeedback1;
delete myRTCPFeedback2;
delete transport1;
delete transport2;
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_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_receiver2_;
RtpRtcp* module1;
@ -149,30 +132,25 @@ class RtpRtcpRtcpTest : public ::testing::Test {
TestRtpReceiver* receiver;
LoopBackTransport* transport1;
LoopBackTransport* transport2;
RtcpCallback* myRTCPFeedback1;
RtcpCallback* myRTCPFeedback2;
uint32_t test_ssrc;
uint32_t test_timestamp;
uint16_t test_sequence_number;
std::vector<uint32_t> test_csrcs;
SimulatedClock fake_clock;
const std::vector<uint32_t> kCsrcs = {1234, 2345};
SimulatedClock fake_clock_;
RateLimiter retransmission_rate_limiter_;
};
TEST_F(RtpRtcpRtcpTest, RTCP_CNAME) {
// Set cname of mixed.
EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[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[0], "john@192.168.0.1"));
EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[1], "jane@192.168.0.2"));
EXPECT_EQ(-1, module1->RemoveMixedCNAME(test_csrcs[0] + 1));
EXPECT_EQ(0, module1->RemoveMixedCNAME(test_csrcs[1]));
EXPECT_EQ(0, module1->AddMixedCNAME(test_csrcs[1], "jane@192.168.0.2"));
EXPECT_EQ(-1, module1->RemoveMixedCNAME(kCsrcs[0] + 1));
EXPECT_EQ(0, module1->RemoveMixedCNAME(kCsrcs[1]));
EXPECT_EQ(0, module1->AddMixedCNAME(kCsrcs[1], "jane@192.168.0.2"));
// send RTCP packet, triggered by timer
fake_clock.AdvanceTimeMilliseconds(7500);
// Send RTCP packet, triggered by timer.
fake_clock_.AdvanceTimeMilliseconds(7500);
module1->Process();
fake_clock.AdvanceTimeMilliseconds(100);
fake_clock_.AdvanceTimeMilliseconds(100);
module2->Process();
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, 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, 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, module1->SetSendingStatus(false));
// Test that BYE clears the CNAME
// Test that BYE clears the 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(0u, report_blocks.size());
// send RTCP packet, triggered by timer
fake_clock.AdvanceTimeMilliseconds(7500);
// Send RTCP packet, triggered by timer.
fake_clock_.AdvanceTimeMilliseconds(7500);
module1->Process();
fake_clock.AdvanceTimeMilliseconds(100);
fake_clock_.AdvanceTimeMilliseconds(100);
module2->Process();
EXPECT_EQ(0, module1->RemoteRTCPStat(&report_blocks));
ASSERT_EQ(1u, report_blocks.size());
// |test_ssrc+1| is the SSRC of module2 that send the report.
EXPECT_EQ(test_ssrc + 1, report_blocks[0].sender_ssrc);
EXPECT_EQ(test_ssrc, report_blocks[0].source_ssrc);
// |kSsrc+1| is the SSRC of module2 that send the report.
EXPECT_EQ(kSsrc + 1, report_blocks[0].sender_ssrc);
EXPECT_EQ(kSsrc, report_blocks[0].source_ssrc);
EXPECT_EQ(0, report_blocks[0].packets_lost);
EXPECT_LT(0u, report_blocks[0].delay_since_last_sender_report);
EXPECT_EQ(test_sequence_number,
report_blocks[0].extended_highest_sequence_number);
EXPECT_EQ(kSequenceNumber, report_blocks[0].extended_highest_sequence_number);
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 <memory>
#include <vector>
#include "api/video_codecs/video_codec.h"
#include "modules/rtp_rtcp/include/rtp_payload_registry.h"
@ -25,7 +24,7 @@
#include "test/gtest.h"
namespace {
const uint32_t kSsrc = 3456;
const unsigned char kPayloadType = 100;
};
@ -34,29 +33,25 @@ namespace webrtc {
class RtpRtcpVideoTest : public ::testing::Test {
protected:
RtpRtcpVideoTest()
: test_ssrc_(3456),
test_timestamp_(4567),
test_sequence_number_(2345),
fake_clock(123456),
retransmission_rate_limiter_(&fake_clock, 1000) {}
: fake_clock_(123456), retransmission_rate_limiter_(&fake_clock_, 1000) {}
~RtpRtcpVideoTest() override = default;
void SetUp() override {
transport_ = new LoopBackTransport();
receiver_ = new TestRtpReceiver();
receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock));
receive_statistics_.reset(ReceiveStatistics::Create(&fake_clock_));
RtpRtcp::Configuration configuration;
configuration.audio = false;
configuration.clock = &fake_clock;
configuration.clock = &fake_clock_;
configuration.outgoing_transport = transport_;
configuration.retransmission_rate_limiter = &retransmission_rate_limiter_;
video_module_ = RtpRtcp::CreateRtpRtcp(configuration);
rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver(
&fake_clock, receiver_, &rtp_payload_registry_));
&fake_clock_, receiver_, &rtp_payload_registry_));
video_module_->SetRTCPStatus(RtcpMode::kCompound);
video_module_->SetSSRC(test_ssrc_);
video_module_->SetSSRC(kSsrc);
video_module_->SetStorePacketsStatus(true, 600);
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 sequence_number) {
dataBuffer[0] = static_cast<uint8_t>(0x80); // version 2
dataBuffer[1] = static_cast<uint8_t>(kPayloadType);
ByteWriter<uint16_t>::WriteBigEndian(dataBuffer + 2, sequence_number);
ByteWriter<uint32_t>::WriteBigEndian(dataBuffer + 4, timestamp);
ByteWriter<uint32_t>::WriteBigEndian(dataBuffer + 8, 0x1234); // SSRC.
buffer[0] = static_cast<uint8_t>(0x80); // version 2
buffer[1] = static_cast<uint8_t>(kPayloadType);
ByteWriter<uint16_t>::WriteBigEndian(buffer + 2, sequence_number);
ByteWriter<uint32_t>::WriteBigEndian(buffer + 4, timestamp);
ByteWriter<uint32_t>::WriteBigEndian(buffer + 8, 0x1234); // SSRC.
size_t rtpHeaderLength = 12;
return rtpHeaderLength;
}
@ -122,19 +117,15 @@ class RtpRtcpVideoTest : public ::testing::Test {
delete receiver_;
}
int test_id_;
std::unique_ptr<ReceiveStatistics> receive_statistics_;
RTPPayloadRegistry rtp_payload_registry_;
std::unique_ptr<RtpReceiver> rtp_receiver_;
RtpRtcp* video_module_;
LoopBackTransport* transport_;
TestRtpReceiver* receiver_;
uint32_t test_ssrc_;
uint32_t test_timestamp_;
uint16_t test_sequence_number_;
uint8_t video_frame_[65000];
size_t payload_data_length_;
SimulatedClock fake_clock;
SimulatedClock fake_clock_;
RateLimiter retransmission_rate_limiter_;
};
@ -174,7 +165,7 @@ TEST_F(RtpRtcpVideoTest, PaddingOnlyFrames) {
EXPECT_EQ(payload_length, receiver_->rtp_header().header.paddingLength);
}
timestamp += 3000;
fake_clock.AdvanceTimeMilliseconds(33);
fake_clock_.AdvanceTimeMilliseconds(33);
}
}