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

Reland "Use RtpSenderEgress directly instead of via RTPSender"

Browse Source 
This is a reland of b533010bc66a0628c8efa4d6c3dd60b8336f2736

Patchset 1 is identical to previously landed CL.
Patchset 2 contains a workaround to migrate downstream tests.

Original change's description:
> Use RtpSenderEgress directly instead of via RTPSender
>
> Bug: webrtc:11036
> Change-Id: Ida4e8bc705ae43ceb1b131114707b30d10ba8642
> Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158521
> Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
> Commit-Queue: Erik Språng <sprang@webrtc.org>
> Cr-Commit-Position: refs/heads/master@{#29626}

Bug: webrtc:11036
Change-Id: I8054169036a7f9f262308cac59f12ac8f9c73c17
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158531
Reviewed-by: Ilya Nikolaevskiy <ilnik@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29635}
This commit is contained in:
Erik Språng
2019-10-28 15:51:36 +01:00
committed by Commit Bot
parent 79e653c46d
commit 77b7529515
5 changed files with 597 additions and 484 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@ -38,6 +38,16 @@ const int64_t kRtpRtcpBitrateProcessTimeMs = 10;
const int64_t kDefaultExpectedRetransmissionTimeMs = 125;
} // namespace
ModuleRtpRtcpImpl::RtpSenderContext::RtpSenderContext(
const RtpRtcp::Configuration& config)
: packet_history_(config.clock),
packet_sender_(config, &packet_history_),
non_paced_sender_(&packet_sender_),
packet_generator_(
config,
&packet_history_,
config.paced_sender ? config.paced_sender : &non_paced_sender_) {}
RtpRtcp::Configuration::Configuration() = default;
RtpRtcp::Configuration::Configuration(Configuration&& rhs) = default;
@ -62,9 +72,10 @@ ModuleRtpRtcpImpl::ModuleRtpRtcpImpl(const Configuration& configuration)
rtt_stats_(configuration.rtt_stats),
rtt_ms_(0) {
if (!configuration.receiver_only) {
rtp_sender_.reset(new RTPSender(configuration));
rtp_sender_ = std::make_unique<RtpSenderContext>(configuration);
// Make sure rtcp sender use same timestamp offset as rtp sender.
rtcp_sender_.SetTimestampOffset(rtp_sender_->TimestampOffset());
rtcp_sender_.SetTimestampOffset(
rtp_sender_->packet_generator_.TimestampOffset());
}
// Set default packet size limit.
@ -90,7 +101,7 @@ void ModuleRtpRtcpImpl::Process() {
if (rtp_sender_) {
if (now >= last_bitrate_process_time_ + kRtpRtcpBitrateProcessTimeMs) {
rtp_sender_->ProcessBitrate();
rtp_sender_->packet_sender_.ProcessBitrateAndNotifyObservers();
last_bitrate_process_time_ = now;
next_process_time_ =
std::min(next_process_time_, now + kRtpRtcpBitrateProcessTimeMs);
@ -168,25 +179,27 @@ void ModuleRtpRtcpImpl::Process() {
}
void ModuleRtpRtcpImpl::SetRtxSendStatus(int mode) {
rtp_sender_->SetRtxStatus(mode);
rtp_sender_->packet_generator_.SetRtxStatus(mode);
}
int ModuleRtpRtcpImpl::RtxSendStatus() const {
return rtp_sender_ ? rtp_sender_->RtxStatus() : kRtxOff;
return rtp_sender_ ? rtp_sender_->packet_generator_.RtxStatus() : kRtxOff;
}
void ModuleRtpRtcpImpl::SetRtxSendPayloadType(int payload_type,
int associated_payload_type) {
rtp_sender_->SetRtxPayloadType(payload_type, associated_payload_type);
rtp_sender_->packet_generator_.SetRtxPayloadType(payload_type,
associated_payload_type);
}
absl::optional<uint32_t> ModuleRtpRtcpImpl::RtxSsrc() const {
return rtp_sender_ ? rtp_sender_->RtxSsrc() : absl::nullopt;
return rtp_sender_ ? rtp_sender_->packet_generator_.RtxSsrc() : absl::nullopt;
}
absl::optional<uint32_t> ModuleRtpRtcpImpl::FlexfecSsrc() const {
if (rtp_sender_)
return rtp_sender_->FlexfecSsrc();
if (rtp_sender_) {
return rtp_sender_->packet_generator_.FlexfecSsrc();
}
return absl::nullopt;
}
@ -205,50 +218,54 @@ int32_t ModuleRtpRtcpImpl::DeRegisterSendPayload(const int8_t payload_type) {
}
uint32_t ModuleRtpRtcpImpl::StartTimestamp() const {
return rtp_sender_->TimestampOffset();
return rtp_sender_->packet_generator_.TimestampOffset();
}
// Configure start timestamp, default is a random number.
void ModuleRtpRtcpImpl::SetStartTimestamp(const uint32_t timestamp) {
rtcp_sender_.SetTimestampOffset(timestamp);
rtp_sender_->SetTimestampOffset(timestamp);
rtp_sender_->packet_generator_.SetTimestampOffset(timestamp);
}
uint16_t ModuleRtpRtcpImpl::SequenceNumber() const {
return rtp_sender_->SequenceNumber();
return rtp_sender_->packet_generator_.SequenceNumber();
}
// Set SequenceNumber, default is a random number.
void ModuleRtpRtcpImpl::SetSequenceNumber(const uint16_t seq_num) {
rtp_sender_->SetSequenceNumber(seq_num);
rtp_sender_->packet_generator_.SetSequenceNumber(seq_num);
}
void ModuleRtpRtcpImpl::SetRtpState(const RtpState& rtp_state) {
rtp_sender_->SetRtpState(rtp_state);
rtp_sender_->packet_generator_.SetRtpState(rtp_state);
rtp_sender_->packet_sender_.SetMediaHasBeenSent(
rtp_state.media_has_been_sent);
rtcp_sender_.SetTimestampOffset(rtp_state.start_timestamp);
}
void ModuleRtpRtcpImpl::SetRtxState(const RtpState& rtp_state) {
rtp_sender_->SetRtxRtpState(rtp_state);
rtp_sender_->packet_generator_.SetRtxRtpState(rtp_state);
}
RtpState ModuleRtpRtcpImpl::GetRtpState() const {
return rtp_sender_->GetRtpState();
RtpState state = rtp_sender_->packet_generator_.GetRtpState();
state.media_has_been_sent = rtp_sender_->packet_sender_.MediaHasBeenSent();
return state;
}
RtpState ModuleRtpRtcpImpl::GetRtxState() const {
return rtp_sender_->GetRtxRtpState();
return rtp_sender_->packet_generator_.GetRtxRtpState();
}
void ModuleRtpRtcpImpl::SetRid(const std::string& rid) {
if (rtp_sender_) {
rtp_sender_->SetRid(rid);
rtp_sender_->packet_generator_.SetRid(rid);
}
}
void ModuleRtpRtcpImpl::SetMid(const std::string& mid) {
if (rtp_sender_) {
rtp_sender_->SetMid(mid);
rtp_sender_->packet_generator_.SetMid(mid);
}
// TODO(bugs.webrtc.org/4050): If we end up supporting the MID SDES item for
// RTCP, this will need to be passed down to the RTCPSender also.
@ -256,7 +273,7 @@ void ModuleRtpRtcpImpl::SetMid(const std::string& mid) {
void ModuleRtpRtcpImpl::SetCsrcs(const std::vector<uint32_t>& csrcs) {
rtcp_sender_.SetCsrcs(csrcs);
rtp_sender_->SetCsrcs(csrcs);
rtp_sender_->packet_generator_.SetCsrcs(csrcs);
}
// TODO(pbos): Handle media and RTX streams separately (separate RTCP
@ -268,12 +285,13 @@ RTCPSender::FeedbackState ModuleRtpRtcpImpl::GetFeedbackState() {
if (rtp_sender_) {
StreamDataCounters rtp_stats;
StreamDataCounters rtx_stats;
rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
rtp_sender_->packet_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
state.packets_sent =
rtp_stats.transmitted.packets + rtx_stats.transmitted.packets;
state.media_bytes_sent = rtp_stats.transmitted.payload_bytes +
rtx_stats.transmitted.payload_bytes;
state.send_bitrate = rtp_sender_->BitrateSent();
state.send_bitrate =
rtp_sender_->packet_sender_.SendBitrate().bps<uint32_t>();
}
state.module = this;
@ -307,19 +325,20 @@ bool ModuleRtpRtcpImpl::Sending() const {
// updated.
void ModuleRtpRtcpImpl::SetSendingMediaStatus(const bool sending) {
if (rtp_sender_) {
rtp_sender_->SetSendingMediaStatus(sending);
rtp_sender_->packet_generator_.SetSendingMediaStatus(sending);
} else {
RTC_DCHECK(!sending);
}
}
bool ModuleRtpRtcpImpl::SendingMedia() const {
return rtp_sender_ ? rtp_sender_->SendingMedia() : false;
return rtp_sender_ ? rtp_sender_->packet_generator_.SendingMedia() : false;
}
void ModuleRtpRtcpImpl::SetAsPartOfAllocation(bool part_of_allocation) {
RTC_CHECK(rtp_sender_);
rtp_sender_->SetAsPartOfAllocation(part_of_allocation);
rtp_sender_->packet_sender_.ForceIncludeSendPacketsInAllocation(
part_of_allocation);
}
bool ModuleRtpRtcpImpl::OnSendingRtpFrame(uint32_t timestamp,
@ -339,30 +358,41 @@ bool ModuleRtpRtcpImpl::OnSendingRtpFrame(uint32_t timestamp,
bool ModuleRtpRtcpImpl::TrySendPacket(RtpPacketToSend* packet,
const PacedPacketInfo& pacing_info) {
return rtp_sender_->TrySendPacket(packet, pacing_info);
RTC_DCHECK(rtp_sender_);
// TODO(sprang): Consider if we can remove this check.
if (!rtp_sender_->packet_generator_.SendingMedia()) {
return false;
}
rtp_sender_->packet_sender_.SendPacket(packet, pacing_info);
return true;
}
void ModuleRtpRtcpImpl::OnPacketsAcknowledged(
rtc::ArrayView<const uint16_t> sequence_numbers) {
RTC_DCHECK(rtp_sender_);
rtp_sender_->OnPacketsAcknowledged(sequence_numbers);
rtp_sender_->packet_history_.CullAcknowledgedPackets(sequence_numbers);
}
bool ModuleRtpRtcpImpl::SupportsPadding() const {
return rtp_sender_->SupportsPadding();
RTC_DCHECK(rtp_sender_);
return rtp_sender_->packet_generator_.SupportsPadding();
}
bool ModuleRtpRtcpImpl::SupportsRtxPayloadPadding() const {
return rtp_sender_->SupportsRtxPayloadPadding();
RTC_DCHECK(rtp_sender_);
return rtp_sender_->packet_generator_.SupportsRtxPayloadPadding();
}
std::vector<std::unique_ptr<RtpPacketToSend>>
ModuleRtpRtcpImpl::GeneratePadding(size_t target_size_bytes) {
return rtp_sender_->GeneratePadding(target_size_bytes);
RTC_DCHECK(rtp_sender_);
return rtp_sender_->packet_generator_.GeneratePadding(
target_size_bytes, rtp_sender_->packet_sender_.MediaHasBeenSent());
}
size_t ModuleRtpRtcpImpl::MaxRtpPacketSize() const {
return rtp_sender_->MaxRtpPacketSize();
RTC_DCHECK(rtp_sender_);
return rtp_sender_->packet_generator_.MaxRtpPacketSize();
}
void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
@ -372,8 +402,9 @@ void ModuleRtpRtcpImpl::SetMaxRtpPacketSize(size_t rtp_packet_size) {
<< "rtp packet size too small: " << rtp_packet_size;
rtcp_sender_.SetMaxRtpPacketSize(rtp_packet_size);
if (rtp_sender_)
rtp_sender_->SetMaxRtpPacketSize(rtp_packet_size);
if (rtp_sender_) {
rtp_sender_->packet_generator_.SetMaxRtpPacketSize(rtp_packet_size);
}
}
RtcpMode ModuleRtpRtcpImpl::RTCP() const {
@ -471,7 +502,7 @@ int32_t ModuleRtpRtcpImpl::DataCountersRTP(size_t* bytes_sent,
uint32_t* packets_sent) const {
StreamDataCounters rtp_stats;
StreamDataCounters rtx_stats;
rtp_sender_->GetDataCounters(&rtp_stats, &rtx_stats);
rtp_sender_->packet_sender_.GetDataCounters(&rtp_stats, &rtx_stats);
if (bytes_sent) {
// TODO(http://crbug.com/webrtc/10525): Bytes sent should only include
@ -493,7 +524,7 @@ int32_t ModuleRtpRtcpImpl::DataCountersRTP(size_t* bytes_sent,
void ModuleRtpRtcpImpl::GetSendStreamDataCounters(
StreamDataCounters* rtp_counters,
StreamDataCounters* rtx_counters) const {
rtp_sender_->GetDataCounters(rtp_counters, rtx_counters);
rtp_sender_->packet_sender_.GetDataCounters(rtp_counters, rtx_counters);
}
// Received RTCP report.
@ -518,28 +549,29 @@ void ModuleRtpRtcpImpl::UnsetRemb() {
}
void ModuleRtpRtcpImpl::SetExtmapAllowMixed(bool extmap_allow_mixed) {
rtp_sender_->SetExtmapAllowMixed(extmap_allow_mixed);
rtp_sender_->packet_generator_.SetExtmapAllowMixed(extmap_allow_mixed);
}
int32_t ModuleRtpRtcpImpl::RegisterSendRtpHeaderExtension(
const RTPExtensionType type,
const uint8_t id) {
return rtp_sender_->RegisterRtpHeaderExtension(type, id);
return rtp_sender_->packet_generator_.RegisterRtpHeaderExtension(type, id);
}
void ModuleRtpRtcpImpl::RegisterRtpHeaderExtension(absl::string_view uri,
int id) {
bool registered = rtp_sender_->RegisterRtpHeaderExtension(uri, id);
bool registered =
rtp_sender_->packet_generator_.RegisterRtpHeaderExtension(uri, id);
RTC_CHECK(registered);
}
int32_t ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
const RTPExtensionType type) {
return rtp_sender_->DeregisterRtpHeaderExtension(type);
return rtp_sender_->packet_generator_.DeregisterRtpHeaderExtension(type);
}
void ModuleRtpRtcpImpl::DeregisterSendRtpHeaderExtension(
absl::string_view uri) {
rtp_sender_->DeregisterRtpHeaderExtension(uri);
rtp_sender_->packet_generator_.DeregisterRtpHeaderExtension(uri);
}
// (TMMBR) Temporary Max Media Bit Rate.
@ -616,11 +648,15 @@ bool ModuleRtpRtcpImpl::TimeToSendFullNackList(int64_t now) const {
// Store the sent packets, needed to answer to Negative acknowledgment requests.
void ModuleRtpRtcpImpl::SetStorePacketsStatus(const bool enable,
const uint16_t number_to_store) {
rtp_sender_->SetStorePacketsStatus(enable, number_to_store);
rtp_sender_->packet_history_.SetStorePacketsStatus(
enable ? RtpPacketHistory::StorageMode::kStoreAndCull
: RtpPacketHistory::StorageMode::kDisabled,
number_to_store);
}
bool ModuleRtpRtcpImpl::StorePackets() const {
return rtp_sender_->StorePackets();
return rtp_sender_->packet_history_.GetStorageMode() !=
RtpPacketHistory::StorageMode::kDisabled;
}
void ModuleRtpRtcpImpl::RegisterRtcpStatisticsCallback(
@ -666,12 +702,12 @@ void ModuleRtpRtcpImpl::BitrateSent(uint32_t* total_rate,
uint32_t* video_rate,
uint32_t* fec_rate,
uint32_t* nack_rate) const {
*total_rate = rtp_sender_->BitrateSent();
*total_rate = rtp_sender_->packet_sender_.SendBitrate().bps<uint32_t>();
if (video_rate)
*video_rate = 0;
if (fec_rate)
*fec_rate = 0;
*nack_rate = rtp_sender_->NackOverheadRate();
*nack_rate = rtp_sender_->packet_sender_.NackOverheadRate().bps<uint32_t>();
}
void ModuleRtpRtcpImpl::OnRequestSendReport() {
@ -683,7 +719,7 @@ void ModuleRtpRtcpImpl::OnReceivedNack(
if (!rtp_sender_)
return;
if (!rtp_sender_->StorePackets() || nack_sequence_numbers.empty()) {
if (!StorePackets() || nack_sequence_numbers.empty()) {
return;
}
// Use RTT from RtcpRttStats class if provided.
@ -691,7 +727,7 @@ void ModuleRtpRtcpImpl::OnReceivedNack(
if (rtt == 0) {
rtcp_receiver_.RTT(rtcp_receiver_.RemoteSSRC(), NULL, &rtt, NULL, NULL);
}
rtp_sender_->OnReceivedNack(nack_sequence_numbers, rtt);
rtp_sender_->packet_generator_.OnReceivedNack(nack_sequence_numbers, rtt);
}
void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
@ -699,18 +735,18 @@ void ModuleRtpRtcpImpl::OnReceivedRtcpReportBlocks(
if (ack_observer_) {
uint32_t ssrc = SSRC();
absl::optional<uint32_t> rtx_ssrc;
if (rtp_sender_->RtxStatus() != kRtxOff) {
rtx_ssrc = rtp_sender_->RtxSsrc();
if (rtp_sender_->packet_generator_.RtxStatus() != kRtxOff) {
rtx_ssrc = rtp_sender_->packet_generator_.RtxSsrc();
}
for (const RTCPReportBlock& report_block : report_blocks) {
if (ssrc == report_block.source_ssrc) {
rtp_sender_->OnReceivedAckOnSsrc(
rtp_sender_->packet_generator_.OnReceivedAckOnSsrc(
report_block.extended_highest_sequence_number);
ack_observer_->OnReceivedAck(
report_block.extended_highest_sequence_number);
} else if (rtx_ssrc && *rtx_ssrc == report_block.source_ssrc) {
rtp_sender_->OnReceivedAckOnRtxSsrc(
rtp_sender_->packet_generator_.OnReceivedAckOnRtxSsrc(
report_block.extended_highest_sequence_number);
}
}
@ -742,8 +778,9 @@ std::vector<rtcp::TmmbItem> ModuleRtpRtcpImpl::BoundingSet(bool* tmmbr_owner) {
void ModuleRtpRtcpImpl::set_rtt_ms(int64_t rtt_ms) {
rtc::CritScope cs(&critical_section_rtt_);
rtt_ms_ = rtt_ms;
if (rtp_sender_)
rtp_sender_->SetRtt(rtt_ms);
if (rtp_sender_) {
rtp_sender_->packet_history_.SetRtt(rtt_ms);
}
}
int64_t ModuleRtpRtcpImpl::rtt_ms() const {
@ -757,19 +794,21 @@ void ModuleRtpRtcpImpl::SetVideoBitrateAllocation(
}
RTPSender* ModuleRtpRtcpImpl::RtpSender() {
return rtp_sender_.get();
return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
}
const RTPSender* ModuleRtpRtcpImpl::RtpSender() const {
return rtp_sender_.get();
return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
}
DataRate ModuleRtpRtcpImpl::SendRate() const {
return DataRate::bps(rtp_sender_->BitrateSent());
RTC_DCHECK(rtp_sender_);
return rtp_sender_->packet_sender_.SendBitrate();
}
DataRate ModuleRtpRtcpImpl::NackOverheadRate() const {
return DataRate::bps(rtp_sender_->NackOverheadRate());
RTC_DCHECK(rtp_sender_);
return rtp_sender_->packet_sender_.NackOverheadRate();
}
} // namespace webrtc

26
modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@ -29,8 +29,10 @@
#include "modules/rtp_rtcp/source/rtcp_packet/tmmb_item.h"
#include "modules/rtp_rtcp/source/rtcp_receiver.h"
#include "modules/rtp_rtcp/source/rtcp_sender.h"
#include "modules/rtp_rtcp/source/rtp_packet_history.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "modules/rtp_rtcp/source/rtp_sender.h"
#include "modules/rtp_rtcp/source/rtp_sender_egress.h"
#include "rtc_base/critical_section.h"
#include "rtc_base/gtest_prod_util.h"
@ -278,8 +280,12 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
protected:
bool UpdateRTCPReceiveInformationTimers();
RTPSender* rtp_sender() { return rtp_sender_.get(); }
const RTPSender* rtp_sender() const { return rtp_sender_.get(); }
RTPSender* rtp_sender() {
return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
}
const RTPSender* rtp_sender() const {
return rtp_sender_ ? &rtp_sender_->packet_generator_ : nullptr;
}
RTCPSender* rtcp_sender() { return &rtcp_sender_; }
const RTCPSender* rtcp_sender() const { return &rtcp_sender_; }
@ -296,12 +302,26 @@ class ModuleRtpRtcpImpl : public RtpRtcp, public RTCPReceiver::ModuleRtpRtcp {
FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, Rtt);
FRIEND_TEST_ALL_PREFIXES(RtpRtcpImplTest, RttForReceiverOnly);
struct RtpSenderContext {
explicit RtpSenderContext(const RtpRtcp::Configuration& config);
// Storage of packets, for retransmissions and padding, if applicable.
RtpPacketHistory packet_history_;
// Handles final time timestamping/stats/etc and handover to Transport.
RtpSenderEgress packet_sender_;
// If no paced sender configured, this class will be used to pass packets
// from |packet_generator_| to |packet_sender_|.
RtpSenderEgress::NonPacedPacketSender non_paced_sender_;
// Handles creation of RTP packets to be sent.
RTPSender packet_generator_;
};
void set_rtt_ms(int64_t rtt_ms);
int64_t rtt_ms() const;
bool TimeToSendFullNackList(int64_t now) const;
std::unique_ptr<RTPSender> rtp_sender_;
std::unique_ptr<RtpSenderContext> rtp_sender_;
RTCPSender rtcp_sender_;
RTCPReceiver rtcp_receiver_;

16
modules/rtp_rtcp/source/rtp_sender_audio_unittest.cc
View File

@ -10,6 +10,7 @@
#include "modules/rtp_rtcp/source/rtp_sender_audio.h"
#include <memory>
#include <vector>
#include "api/transport/field_trial_based_config.h"
@ -17,7 +18,6 @@
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_sender.h"
#include "test/gmock.h"
#include "test/gtest.h"
@ -63,21 +63,21 @@ class RtpSenderAudioTest : public ::testing::Test {
public:
RtpSenderAudioTest()
: fake_clock_(kStartTime),
rtp_sender_([&] {
rtp_module_(RtpRtcp::Create([&] {
RtpRtcp::Configuration config;
config.audio = true;
config.clock = &fake_clock_;
config.outgoing_transport = &transport_;
config.local_media_ssrc = kSsrc;
return config;
}()),
rtp_sender_audio_(&fake_clock_, &rtp_sender_) {
rtp_sender_.SetSequenceNumber(kSeqNum);
}())),
rtp_sender_audio_(&fake_clock_, rtp_module_->RtpSender()) {
rtp_module_->SetSequenceNumber(kSeqNum);
}
SimulatedClock fake_clock_;
LoopbackTransportTest transport_;
RTPSender rtp_sender_;
std::unique_ptr<RtpRtcp> rtp_module_;
RTPSenderAudio rtp_sender_audio_;
};
@ -98,8 +98,8 @@ TEST_F(RtpSenderAudioTest, SendAudio) {
TEST_F(RtpSenderAudioTest, SendAudioWithAudioLevelExtension) {
EXPECT_EQ(0, rtp_sender_audio_.SetAudioLevel(kAudioLevel));
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(kRtpExtensionAudioLevel,
kAudioLevelExtensionId));
rtp_module_->RegisterRtpHeaderExtension(AudioLevel::kUri,
kAudioLevelExtensionId);
const char payload_name[] = "PAYLOAD_NAME";
const uint8_t payload_type = 127;

833
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

File diff suppressed because it is too large Load Diff

55
modules/rtp_rtcp/source/rtp_sender_video_unittest.cc
View File

@ -17,13 +17,13 @@
#include "api/video/video_timing.h"
#include "modules/rtp_rtcp/include/rtp_cvo.h"
#include "modules/rtp_rtcp/include/rtp_header_extension_map.h"
#include "modules/rtp_rtcp/include/rtp_rtcp.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtp_format_video_generic.h"
#include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor.h"
#include "modules/rtp_rtcp/source/rtp_generic_frame_descriptor_extension.h"
#include "modules/rtp_rtcp/source/rtp_header_extensions.h"
#include "modules/rtp_rtcp/source/rtp_packet_received.h"
#include "modules/rtp_rtcp/source/rtp_sender.h"
#include "rtc_base/arraysize.h"
#include "rtc_base/rate_limiter.h"
#include "test/gmock.h"
@ -142,7 +142,7 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
: field_trials_(GetParam()),
fake_clock_(kStartTime),
retransmission_rate_limiter_(&fake_clock_, 1000),
rtp_sender_([&] {
rtp_module_(RtpRtcp::Create([&] {
RtpRtcp::Configuration config;
config.clock = &fake_clock_;
config.outgoing_transport = &transport_;
@ -150,10 +150,13 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
config.field_trials = &field_trials_;
config.local_media_ssrc = kSsrc;
return config;
}()),
rtp_sender_video_(&fake_clock_, &rtp_sender_, nullptr, field_trials_) {
rtp_sender_.SetSequenceNumber(kSeqNum);
rtp_sender_.SetTimestampOffset(0);
}())),
rtp_sender_video_(&fake_clock_,
rtp_module_->RtpSender(),
nullptr,
field_trials_) {
rtp_module_->SetSequenceNumber(kSeqNum);
rtp_module_->SetStartTimestamp(0);
}
void PopulateGenericFrameDescriptor(int version);
@ -162,19 +165,19 @@ class RtpSenderVideoTest : public ::testing::TestWithParam<bool> {
int version);
protected:
const RtpRtcp::Configuration config_;
FieldTrials field_trials_;
SimulatedClock fake_clock_;
LoopbackTransportTest transport_;
RateLimiter retransmission_rate_limiter_;
RTPSender rtp_sender_;
std::unique_ptr<RtpRtcp> rtp_module_;
TestRtpSenderVideo rtp_sender_video_;
};
TEST_P(RtpSenderVideoTest, KeyFrameHasCVO) {
uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
rtp_module_->RegisterRtpHeaderExtension(VideoOrientation::kUri,
kVideoRotationExtensionId);
RTPVideoHeader hdr;
hdr.rotation = kVideoRotation_0;
@ -193,8 +196,8 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) {
const int64_t kPacketizationTimeMs = 100;
const int64_t kEncodeStartDeltaMs = 10;
const int64_t kEncodeFinishDeltaMs = 50;
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(kRtpExtensionVideoTiming,
kVideoTimingExtensionId));
rtp_module_->RegisterRtpHeaderExtension(VideoTimingExtension::kUri,
kVideoTimingExtensionId);
const int64_t kCaptureTimestamp = fake_clock_.TimeInMilliseconds();
@ -218,8 +221,8 @@ TEST_P(RtpSenderVideoTest, TimingFrameHasPacketizationTimstampSet) {
TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
rtp_module_->RegisterRtpHeaderExtension(VideoOrientation::kUri,
kVideoRotationExtensionId);
RTPVideoHeader hdr;
hdr.rotation = kVideoRotation_90;
@ -242,8 +245,8 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenChanged) {
TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
kRtpExtensionVideoRotation, kVideoRotationExtensionId));
rtp_module_->RegisterRtpHeaderExtension(VideoOrientation::kUri,
kVideoRotationExtensionId);
RTPVideoHeader hdr;
hdr.rotation = kVideoRotation_90;
@ -265,8 +268,8 @@ TEST_P(RtpSenderVideoTest, DeltaFrameHasCVOWhenNonZero) {
TEST_P(RtpSenderVideoTest, CheckH264FrameMarking) {
uint8_t kFrame[kMaxPacketLength];
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(
kRtpExtensionFrameMarking, kFrameMarkingExtensionId));
rtp_module_->RegisterRtpHeaderExtension(FrameMarkingExtension::kUri,
kFrameMarkingExtensionId);
RTPFragmentationHeader frag;
frag.VerifyAndAllocateFragmentationHeader(1);
@ -513,15 +516,15 @@ TEST_P(RtpSenderVideoTest, ConditionalRetransmitLimit) {
}
void RtpSenderVideoTest::PopulateGenericFrameDescriptor(int version) {
const RTPExtensionType ext_type =
(version == 0) ? RTPExtensionType::kRtpExtensionGenericFrameDescriptor00
: RTPExtensionType::kRtpExtensionGenericFrameDescriptor01;
const absl::string_view ext_uri =
(version == 0) ? RtpGenericFrameDescriptorExtension00::kUri
: RtpGenericFrameDescriptorExtension01::kUri;
const int ext_id =
(version == 0) ? kGenericDescriptorId00 : kGenericDescriptorId01;
const int64_t kFrameId = 100000;
uint8_t kFrame[100];
EXPECT_EQ(0, rtp_sender_.RegisterRtpHeaderExtension(ext_type, ext_id));
rtp_module_->RegisterRtpHeaderExtension(ext_uri, ext_id);
RTPVideoHeader hdr;
RTPVideoHeader::GenericDescriptorInfo& generic = hdr.generic.emplace();
@ -569,11 +572,11 @@ void RtpSenderVideoTest::
uint8_t kFrame[kFrameSize];
if (version == 0) {
ASSERT_TRUE(rtp_sender_.RegisterRtpHeaderExtension(
RtpGenericFrameDescriptorExtension00::kUri, kGenericDescriptorId00));
rtp_module_->RegisterRtpHeaderExtension(
RtpGenericFrameDescriptorExtension00::kUri, kGenericDescriptorId00);
} else {
ASSERT_TRUE(rtp_sender_.RegisterRtpHeaderExtension(
RtpGenericFrameDescriptorExtension01::kUri, kGenericDescriptorId01));
rtp_module_->RegisterRtpHeaderExtension(
RtpGenericFrameDescriptorExtension01::kUri, kGenericDescriptorId01);
}
RTPVideoHeader hdr;