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

Revert "Use RtpSenderEgress directly instead of via RTPSender"

Browse Source 
This reverts commit b533010bc66a0628c8efa4d6c3dd60b8336f2736.

Reason for revert: Breaks 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}

TBR=ilnik@webrtc.org,sprang@webrtc.org

Change-Id: Ib3354f6907d21462a8ad0c37eb8f6e94c48af217
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: webrtc:11036
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158526
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Erik Språng <sprang@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#29627}
This commit is contained in:
Erik Språng
2019-10-28 11:17:07 +00:00
committed by Commit Bot
parent b533010bc6
commit a81e2b4510
5 changed files with 484 additions and 595 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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