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

Move ownership of RTPSenderVideo one more level up, to RtpVideoSender

Browse Source 
The idea is to let the RtpRtcp and RTPSender classes be responsible for
media-agnostic RTP transport, and move out the media-specific processing,
such as packetization and media-specific headers.

Bug: webrtc:7135
Change-Id: Ib0ce45bf06713b3eb6c06acd91c5168856874e4e
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/123187
Reviewed-by: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Danil Chapovalov <danilchap@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#26954}
This commit is contained in:
Niels Möller
2019-03-04 16:49:25 +01:00
committed by Commit Bot
parent ac6cf7f089
commit 5fe9510efb
15 changed files with 383 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@ -12,9 +12,12 @@
#include <memory>
#include <set>
#include "absl/memory/memory.h"
#include "api/transport/field_trial_based_config.h"
#include "api/video_codecs/video_codec.h"
#include "modules/rtp_rtcp/include/rtp_header_parser.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/playout_delay_oracle.h"
#include "modules/rtp_rtcp/source/rtcp_packet.h"
#include "modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
@ -199,11 +202,15 @@ class RtpRtcpImplTest : public ::testing::Test {
sender_.impl_->SetSequenceNumber(kSequenceNumber);
sender_.impl_->SetStorePacketsStatus(true, 100);
sender_video_ = absl::make_unique<RTPSenderVideo>(
&clock_, sender_.impl_->RtpSender(), nullptr, &playout_delay_oracle_,
nullptr, false, FieldTrialBasedConfig());
memset(&codec_, 0, sizeof(VideoCodec));
codec_.plType = 100;
codec_.width = 320;
codec_.height = 180;
sender_.impl_->RegisterVideoSendPayload(codec_.plType, "VP8");
sender_video_->RegisterPayloadType(codec_.plType, "VP8");
// Receive module.
EXPECT_EQ(0, receiver_.impl_->SetSendingStatus(false));
@ -217,10 +224,14 @@ class RtpRtcpImplTest : public ::testing::Test {
SimulatedClock clock_;
RtpRtcpModule sender_;
PlayoutDelayOracle playout_delay_oracle_;
std::unique_ptr<RTPSenderVideo> sender_video_;
RtpRtcpModule receiver_;
VideoCodec codec_;
void SendFrame(const RtpRtcpModule* module, uint8_t tid) {
void SendFrame(const RtpRtcpModule* module,
RTPSenderVideo* sender,
uint8_t tid) {
RTPVideoHeaderVP8 vp8_header = {};
vp8_header.temporalIdx = tid;
RTPVideoHeader rtp_video_header;
@ -236,9 +247,10 @@ class RtpRtcpImplTest : public ::testing::Test {
rtp_video_header.video_timing = {0u, 0u, 0u, 0u, 0u, 0u, false};
const uint8_t payload[100] = {0};
EXPECT_EQ(true, module->impl_->SendOutgoingData(
kVideoFrameKey, codec_.plType, 0, 0, payload,
sizeof(payload), nullptr, &rtp_video_header, nullptr));
EXPECT_TRUE(module->impl_->OnSendingRtpFrame(0, 0, codec_.plType, true));
EXPECT_TRUE(sender->SendVideo(kVideoFrameKey, codec_.plType, 0, 0, payload,
sizeof(payload), nullptr, &rtp_video_header,
0));
}
void IncomingRtcpNack(const RtpRtcpModule* module, uint16_t sequence_number) {
@ -258,9 +270,11 @@ class RtpRtcpImplTest : public ::testing::Test {
TEST_F(RtpRtcpImplTest, RetransmitsAllLayers) {
// Send frames.
EXPECT_EQ(0, sender_.RtpSent());
SendFrame(&sender_, kBaseLayerTid); // kSequenceNumber
SendFrame(&sender_, kHigherLayerTid); // kSequenceNumber + 1
SendFrame(&sender_, kNoTemporalIdx); // kSequenceNumber + 2
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid); // kSequenceNumber
SendFrame(&sender_, sender_video_.get(),
kHigherLayerTid); // kSequenceNumber + 1
SendFrame(&sender_, sender_video_.get(),
kNoTemporalIdx); // kSequenceNumber + 2
EXPECT_EQ(3, sender_.RtpSent());
EXPECT_EQ(kSequenceNumber + 2, sender_.LastRtpSequenceNumber());
@ -290,7 +304,7 @@ TEST_F(RtpRtcpImplTest, Rtt) {
receiver_.receive_statistics_->OnRtpPacket(packet);
// Send Frame before sending an SR.
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
// Sender module should send an SR.
EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
@ -338,7 +352,7 @@ TEST_F(RtpRtcpImplTest, RttForReceiverOnly) {
// Sender module should send a response to the last received RTRR (DLRR).
clock_.AdvanceTimeMilliseconds(1000);
// Send Frame before sending a SR.
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
EXPECT_EQ(0, sender_.impl_->SendRTCP(kRtcpReport));
// Verify RTT.
@ -367,7 +381,7 @@ TEST_F(RtpRtcpImplTest, NoSrBeforeMedia) {
EXPECT_EQ(-1, sender_.RtcpSent().first_packet_time_ms);
EXPECT_EQ(receiver_.RtcpSent().first_packet_time_ms, current_time);
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
EXPECT_EQ(sender_.RtcpSent().first_packet_time_ms, current_time);
}
@ -459,7 +473,7 @@ TEST_F(RtpRtcpImplTest, SendsInitialNackList) {
uint16_t nack_list[kNackLength] = {123};
EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
// Send Frame before sending a compound RTCP that starts with SR.
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
@ -471,7 +485,7 @@ TEST_F(RtpRtcpImplTest, SendsExtendedNackList) {
uint16_t nack_list[kNackLength] = {123};
EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
// Send Frame before sending a compound RTCP that starts with SR.
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123));
@ -496,7 +510,7 @@ TEST_F(RtpRtcpImplTest, ReSendsNackListAfterRttMs) {
uint16_t nack_list[kNackLength] = {123, 125};
EXPECT_EQ(0U, sender_.RtcpSent().nack_packets);
// Send Frame before sending a compound RTCP that starts with SR.
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
EXPECT_EQ(0, sender_.impl_->SendNACK(nack_list, kNackLength));
EXPECT_EQ(1U, sender_.RtcpSent().nack_packets);
EXPECT_THAT(sender_.LastNackListSent(), ElementsAre(123, 125));
@ -593,7 +607,7 @@ TEST_F(RtpRtcpImplTest, SendsKeepaliveAfterTimout) {
EXPECT_EQ(2U, sender_.transport_.NumKeepaliveSent());
// Send actual payload data, no keep-alive expected.
SendFrame(&sender_, 0);
SendFrame(&sender_, sender_video_.get(), 0);
sender_.impl_->Process();
EXPECT_EQ(2U, sender_.transport_.NumKeepaliveSent());
@ -615,7 +629,7 @@ TEST_F(RtpRtcpImplTest, ConfigurableRtcpReportInterval) {
sender_.SetRtcpReportIntervalAndReset(kVideoReportInterval);
SetUp();
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
// Initial state
sender_.impl_->Process();
@ -634,7 +648,7 @@ TEST_F(RtpRtcpImplTest, ConfigurableRtcpReportInterval) {
EXPECT_GT(sender_.RtcpSent().first_packet_time_ms, -1);
EXPECT_EQ(sender_.transport_.NumRtcpSent(), 1u);
SendFrame(&sender_, kBaseLayerTid);
SendFrame(&sender_, sender_video_.get(), kBaseLayerTid);
// Move ahead to the last possible second before second rtcp is expected.
clock_.AdvanceTimeMilliseconds(kVideoReportInterval * 1 / 2 - 1);