mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-14 06:10:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move SendsPacketsWithTransportSequenceNumber to RtpRtcp level.

Browse source 
New tests (transport sequence number plus newly added abs send time) now
test more of production code and less of rtp_sender_unittest.cc test
fixture code.

Bug: webrtc:11340
Change-Id: I8ec0022c3d18467a4144ce984996af1a452760dc
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/216327
Commit-Queue: Erik Språng <sprang@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#33895}
This commit is contained in:
Erik Språng 2021-05-03 13:54:48 +02:00 committed by WebRTC LUCI CQ
parent 1a1795768e
commit 12d24113dc
2 changed files with 50 additions and 52 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
modules/rtp_rtcp/source/rtp_rtcp_impl2_unittest.cc
View file

@ -51,6 +51,12 @@ const uint8_t kPayloadType = 100;
const int kWidth = 320;
const int kHeight = 100;
// RTP header extension ids.
enum : int {
kAbsoluteSendTimeExtensionId = 1,
kTransportSequenceNumberExtensionId,
};
class RtcpRttStatsTestImpl : public RtcpRttStats {
public:
RtcpRttStatsTestImpl() : rtt_ms_(0) {}
@ -68,7 +74,8 @@ class SendTransport : public Transport {
time_controller_(nullptr),
delay_ms_(0),
rtp_packets_sent_(0),
rtcp_packets_sent_(0) {}
rtcp_packets_sent_(0),
last_packet_(&header_extensions_) {}
void SetRtpRtcpModule(ModuleRtpRtcpImpl2* receiver) { receiver_ = receiver; }
void SimulateNetworkDelay(int64_t delay_ms, TimeController* time_controller) {
@ -78,11 +85,8 @@ class SendTransport : public Transport {
bool SendRtp(const uint8_t* data,
size_t len,
const PacketOptions& options) override {
RTPHeader header;
std::unique_ptr<RtpHeaderParser> parser(RtpHeaderParser::CreateForTest());
EXPECT_TRUE(parser->Parse(static_cast<const uint8_t*>(data), len, &header));
EXPECT_TRUE(last_packet_.Parse(data, len));
++rtp_packets_sent_;
last_rtp_header_ = header;
return true;
}
bool SendRtcp(const uint8_t* data, size_t len) override {
@ -106,8 +110,9 @@ class SendTransport : public Transport {
int64_t delay_ms_;
int rtp_packets_sent_;
size_t rtcp_packets_sent_;
RTPHeader last_rtp_header_;
std::vector<uint16_t> last_nack_list_;
RtpHeaderExtensionMap header_extensions_;
RtpPacketReceived last_packet_;
};
struct TestConfig {
@ -187,9 +192,7 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
return counter_map_[impl_->SSRC()];
}
int RtpSent() { return transport_.rtp_packets_sent_; }
uint16_t LastRtpSequenceNumber() {
return transport_.last_rtp_header_.sequenceNumber;
}
uint16_t LastRtpSequenceNumber() { return last_packet().SequenceNumber(); }
std::vector<uint16_t> LastNackListSent() {
return transport_.last_nack_list_;
}
@ -197,6 +200,12 @@ class RtpRtcpModule : public RtcpPacketTypeCounterObserver {
rtcp_report_interval_ms_ = rtcp_report_interval_ms;
CreateModuleImpl();
}
const RtpPacketReceived& last_packet() { return transport_.last_packet_; }
void RegisterHeaderExtension(absl::string_view uri, int id) {
impl_->RegisterRtpHeaderExtension(uri, id);
transport_.header_extensions_.RegisterByUri(id, uri);
transport_.last_packet_.IdentifyExtensions(transport_.header_extensions_);
}
private:
void CreateModuleImpl() {
@ -863,8 +872,8 @@ TEST_P(RtpRtcpImpl2Test, PaddingTimestampMatchesMedia) {
EXPECT_TRUE(
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, kTimestamp));
EXPECT_EQ(sender_.transport_.last_rtp_header_.timestamp, kTimestamp);
uint16_t media_seq = sender_.transport_.last_rtp_header_.sequenceNumber;
EXPECT_EQ(sender_.last_packet().Timestamp(), kTimestamp);
uint16_t media_seq = sender_.last_packet().SequenceNumber();
// Generate and send padding.
auto padding = sender_.impl_->GeneratePadding(kPaddingSize);
@ -874,8 +883,36 @@ TEST_P(RtpRtcpImpl2Test, PaddingTimestampMatchesMedia) {
}
// Verify we sent a new packet, but with the same timestamp.
EXPECT_NE(sender_.transport_.last_rtp_header_.sequenceNumber, media_seq);
EXPECT_EQ(sender_.transport_.last_rtp_header_.timestamp, kTimestamp);
EXPECT_NE(sender_.last_packet().SequenceNumber(), media_seq);
EXPECT_EQ(sender_.last_packet().Timestamp(), kTimestamp);
}
TEST_P(RtpRtcpImpl2Test, AssignsTransportSequenceNumber) {
sender_.RegisterHeaderExtension(TransportSequenceNumber::kUri,
kTransportSequenceNumberExtensionId);
EXPECT_TRUE(
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, /*timestamp=*/0));
uint16_t first_transport_seq = 0;
EXPECT_TRUE(sender_.last_packet().GetExtension<TransportSequenceNumber>(
&first_transport_seq));
EXPECT_TRUE(
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, /*timestamp=*/0));
uint16_t second_transport_seq = 0;
EXPECT_TRUE(sender_.last_packet().GetExtension<TransportSequenceNumber>(
&second_transport_seq));
EXPECT_EQ(first_transport_seq + 1, second_transport_seq);
}
TEST_P(RtpRtcpImpl2Test, AssignsAbsoluteSendTime) {
sender_.RegisterHeaderExtension(AbsoluteSendTime::kUri,
kAbsoluteSendTimeExtensionId);
EXPECT_TRUE(
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid, /*timestamp=*/0));
EXPECT_NE(sender_.last_packet().GetExtension<AbsoluteSendTime>(), 0u);
}
INSTANTIATE_TEST_SUITE_P(WithAndWithoutOverhead,

39
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View file

@ -545,45 +545,6 @@ TEST_P(RtpSenderTest, PaddingAlwaysAllowedOnAudio) {
EXPECT_EQ(kMinPaddingSize, GenerateAndSendPadding(kMinPaddingSize - 5));
}
TEST_P(RtpSenderTestWithoutPacer, SendsPacketsWithTransportSequenceNumber) {
RtpRtcpInterface::Configuration config;
config.clock = clock_;
config.outgoing_transport = &transport_;
config.local_media_ssrc = kSsrc;
config.transport_feedback_callback = &feedback_observer_;
config.event_log = &mock_rtc_event_log_;
config.send_packet_observer = &send_packet_observer_;
config.retransmission_rate_limiter = &retransmission_rate_limiter_;
rtp_sender_context_ =
std::make_unique<RtpSenderContext>(config, &time_controller_);
EXPECT_TRUE(rtp_sender()->RegisterRtpHeaderExtension(
TransportSequenceNumber::kUri, kTransportSequenceNumberExtensionId));
EXPECT_CALL(send_packet_observer_,
OnSendPacket(kTransportSequenceNumber, _, _))
.Times(1);
EXPECT_CALL(feedback_observer_,
OnAddPacket(AllOf(
Field(&RtpPacketSendInfo::ssrc, rtp_sender()->SSRC()),
Field(&RtpPacketSendInfo::transport_sequence_number,
kTransportSequenceNumber),
Field(&RtpPacketSendInfo::rtp_sequence_number,
rtp_sender()->SequenceNumber()),
Field(&RtpPacketSendInfo::pacing_info, PacedPacketInfo()))))
.Times(1);
SendGenericPacket();
const auto& packet = transport_.last_sent_packet();
uint16_t transport_seq_no;
ASSERT_TRUE(packet.GetExtension<TransportSequenceNumber>(&transport_seq_no));
EXPECT_EQ(kTransportSequenceNumber, transport_seq_no);
EXPECT_EQ(transport_.last_options_.packet_id, transport_seq_no);
EXPECT_TRUE(transport_.last_options_.included_in_allocation);
}
TEST_P(RtpSenderTestWithoutPacer, PacketOptionsNoRetransmission) {
RtpRtcpInterface::Configuration config;
config.clock = clock_;