From 67ac9e8ecb897864e37230e941558bbd380b1f52 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Erik=20Spr=C3=A5ng?= Date: Fri, 25 Oct 2019 15:24:15 +0200 Subject: [PATCH] Prepares RTPSender for extracting RtpSenderEgress MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The post-pacing part of the RTP sender has been moved from RTPSender into the new RtpSenderEgress class. However, that class is not directly used and instead a subset of method calls are passed through RTPSender. This CL prepares for removing dependencies between RTPSender and RtpSenderEgress. All current behavior is preserved, and unit tests are unchanged to verify this. For more context, see patch set 2. Change-Id: If795f2603aeb6302ac1565d9efaea514af240dc7 Bug: webrtc:11036 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/158020 Commit-Queue: Erik Språng Reviewed-by: Ilya Nikolaevskiy Cr-Commit-Position: refs/heads/master@{#29616} --- modules/rtp_rtcp/source/rtp_sender.cc | 108 +++++++++++-------- modules/rtp_rtcp/source/rtp_sender.h | 52 ++++----- modules/rtp_rtcp/source/rtp_sender_audio.cc | 20 +--- modules/rtp_rtcp/source/rtp_sender_audio.h | 2 - modules/rtp_rtcp/source/rtp_sender_egress.cc | 43 +++++++- modules/rtp_rtcp/source/rtp_sender_egress.h | 23 +++- modules/rtp_rtcp/source/rtp_sender_video.cc | 14 ++- 7 files changed, 159 insertions(+), 103 deletions(-) diff --git a/modules/rtp_rtcp/source/rtp_sender.cc b/modules/rtp_rtcp/source/rtp_sender.cc index e2f57febbb..8acdfd2cdd 100644 --- a/modules/rtp_rtcp/source/rtp_sender.cc +++ b/modules/rtp_rtcp/source/rtp_sender.cc @@ -93,24 +93,11 @@ bool HasBweExtension(const RtpHeaderExtensionMap& extensions_map) { } // namespace -RTPSender::NonPacedPacketSender::NonPacedPacketSender(RTPSender* rtp_sender) - : transport_sequence_number_(0), rtp_sender_(rtp_sender) {} -RTPSender::NonPacedPacketSender::~NonPacedPacketSender() = default; - -void RTPSender::NonPacedPacketSender::EnqueuePackets( - std::vector> packets) { - for (auto& packet : packets) { - if (!packet->SetExtension( - ++transport_sequence_number_)) { - --transport_sequence_number_; - } - packet->ReserveExtension(); - packet->ReserveExtension(); - rtp_sender_->TrySendPacket(packet.get(), PacedPacketInfo()); - } -} - RTPSender::RTPSender(const RtpRtcp::Configuration& config) + : RTPSender(config, nullptr, config.paced_sender) {} +RTPSender::RTPSender(const RtpRtcp::Configuration& config, + RtpPacketHistory* packet_history, + RtpPacketSender* packet_sender) : clock_(config.clock), random_(clock_->TimeInMicroseconds()), audio_configured_(config.audio), @@ -119,15 +106,10 @@ RTPSender::RTPSender(const RtpRtcp::Configuration& config) flexfec_ssrc_(config.flexfec_sender ? absl::make_optional(config.flexfec_sender->ssrc()) : absl::nullopt), - non_paced_packet_sender_( - config.paced_sender ? nullptr : new NonPacedPacketSender(this)), - paced_sender_(config.paced_sender ? config.paced_sender - : non_paced_packet_sender_.get()), sending_media_(true), // Default to sending media. max_packet_size_(IP_PACKET_SIZE - 28), // Default is IP-v4/UDP. last_payload_type_(-1), rtp_header_extension_map_(config.extmap_allow_mixed), - packet_history_(clock_), // RTP variables sequence_number_forced_(false), ssrc_has_acked_(false), @@ -139,14 +121,36 @@ RTPSender::RTPSender(const RtpRtcp::Configuration& config) csrcs_(), rtx_(kRtxOff), supports_bwe_extension_(false), - retransmission_rate_limiter_(config.retransmission_rate_limiter), - egress_(config, &packet_history_, clock_) { + retransmission_rate_limiter_(config.retransmission_rate_limiter) { // This random initialization is not intended to be cryptographic strong. timestamp_offset_ = random_.Rand(); // Random start, 16 bits. Can't be 0. sequence_number_rtx_ = random_.Rand(1, kMaxInitRtpSeqNumber); sequence_number_ = random_.Rand(1, kMaxInitRtpSeqNumber); + + if (packet_history == nullptr) { + // Packet history must be provided if using the new split sender, so if it + // is nullptr it means we are in backwards compatibility mode where + // RTPSender owns the history, RtpSenderEgress and non-paced sender adapter. + // TODO(bugs.webrtc.org/11036): Remove. + owned_history_ = std::make_unique(clock_); + packet_history_ = owned_history_.get(); + egress_ = std::make_unique(config, packet_history_); + if (packet_sender) { + paced_sender_ = packet_sender; + } else { + non_paced_packet_sender_ = + std::make_unique( + egress_.get()); + paced_sender_ = non_paced_packet_sender_.get(); + } + } else { + packet_history_ = packet_history; + paced_sender_ = packet_sender; + } + RTC_DCHECK(paced_sender_); + RTC_DCHECK(packet_history_); } RTPSender::~RTPSender() { @@ -172,11 +176,13 @@ rtc::ArrayView RTPSender::VideoExtensionSizes() { } uint16_t RTPSender::ActualSendBitrateKbit() const { - return egress_.SendBitrate().kbps(); + RTC_DCHECK(egress_); + return egress_->SendBitrate().kbps(); } uint32_t RTPSender::NackOverheadRate() const { - return egress_.NackOverheadRate().bps(); + RTC_DCHECK(egress_); + return egress_->NackOverheadRate().bps(); } void RTPSender::SetExtmapAllowMixed(bool extmap_allow_mixed) { @@ -252,14 +258,14 @@ void RTPSender::SetRtxPayloadType(int payload_type, } void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) { - packet_history_.SetStorePacketsStatus( + packet_history_->SetStorePacketsStatus( enable ? RtpPacketHistory::StorageMode::kStoreAndCull : RtpPacketHistory::StorageMode::kDisabled, number_to_store); } bool RTPSender::StorePackets() const { - return packet_history_.GetStorageMode() != + return packet_history_->GetStorageMode() != RtpPacketHistory::StorageMode::kDisabled; } @@ -267,7 +273,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id) { // Try to find packet in RTP packet history. Also verify RTT here, so that we // don't retransmit too often. absl::optional stored_packet = - packet_history_.GetPacketState(packet_id); + packet_history_->GetPacketState(packet_id); if (!stored_packet || stored_packet->pending_transmission) { // Packet not found or already queued for retransmission, ignore. return 0; @@ -277,7 +283,7 @@ int32_t RTPSender::ReSendPacket(uint16_t packet_id) { const bool rtx = (RtxStatus() & kRtxRetransmitted) > 0; std::unique_ptr packet = - packet_history_.GetPacketAndMarkAsPending( + packet_history_->GetPacketAndMarkAsPending( packet_id, [&](const RtpPacketToSend& stored_packet) { // Check if we're overusing retransmission bitrate. // TODO(sprang): Add histograms for nack success or failure @@ -324,7 +330,7 @@ void RTPSender::OnReceivedAckOnRtxSsrc( void RTPSender::OnReceivedNack( const std::vector& nack_sequence_numbers, int64_t avg_rtt) { - packet_history_.SetRtt(5 + avg_rtt); + packet_history_->SetRtt(5 + avg_rtt); for (uint16_t seq_no : nack_sequence_numbers) { const int32_t bytes_sent = ReSendPacket(seq_no); if (bytes_sent < 0) { @@ -348,7 +354,8 @@ bool RTPSender::TrySendPacket(RtpPacketToSend* packet, } } - egress_.SendPacket(packet, pacing_info); + RTC_DCHECK(egress_); + egress_->SendPacket(packet, pacing_info); return true; } @@ -365,6 +372,13 @@ bool RTPSender::SupportsRtxPayloadPadding() const { std::vector> RTPSender::GeneratePadding( size_t target_size_bytes) { + RTC_DCHECK(egress_); + return GeneratePadding(target_size_bytes, egress_->MediaHasBeenSent()); +} + +std::vector> RTPSender::GeneratePadding( + size_t target_size_bytes, + bool media_has_been_sent) { // This method does not actually send packets, it just generates // them and puts them in the pacer queue. Since this should incur // low overhead, keep the lock for the scope of the method in order @@ -375,7 +389,7 @@ std::vector> RTPSender::GeneratePadding( if (SupportsRtxPayloadPadding()) { while (bytes_left >= kMinPayloadPaddingBytes) { std::unique_ptr packet = - packet_history_.GetPayloadPaddingPacket( + packet_history_->GetPayloadPaddingPacket( [&](const RtpPacketToSend& packet) -> std::unique_ptr { return BuildRtxPacket(packet); @@ -436,7 +450,7 @@ std::vector> RTPSender::GeneratePadding( // Without abs-send-time or transport sequence number a media packet // must be sent before padding so that the timestamps used for // estimation are correct. - if (!egress_.MediaHasBeenSent() && + if (!media_has_been_sent && !(rtp_header_extension_map_.IsRegistered(AbsoluteSendTime::kId) || rtp_header_extension_map_.IsRegistered( TransportSequenceNumber::kId))) { @@ -512,7 +526,8 @@ void RTPSender::EnqueuePackets( } void RTPSender::ProcessBitrate() { - egress_.ProcessBitrateAndNotifyObservers(); + RTC_DCHECK(egress_); + egress_->ProcessBitrateAndNotifyObservers(); } size_t RTPSender::RtpHeaderLength() const { @@ -533,7 +548,8 @@ uint16_t RTPSender::AllocateSequenceNumber(uint16_t packets_to_send) { void RTPSender::GetDataCounters(StreamDataCounters* rtp_stats, StreamDataCounters* rtx_stats) const { - egress_.GetDataCounters(rtp_stats, rtx_stats); + RTC_DCHECK(egress_); + egress_->GetDataCounters(rtp_stats, rtx_stats); } std::unique_ptr RTPSender::AllocatePacket() const { @@ -606,7 +622,8 @@ bool RTPSender::SendingMedia() const { } void RTPSender::SetAsPartOfAllocation(bool part_of_allocation) { - egress_.ForceIncludeSendPacketsInAllocation(part_of_allocation); + RTC_DCHECK(egress_); + egress_->ForceIncludeSendPacketsInAllocation(part_of_allocation); } void RTPSender::SetTimestampOffset(uint32_t timestamp) { @@ -653,7 +670,7 @@ void RTPSender::SetSequenceNumber(uint16_t seq) { if (updated_sequence_number) { // Sequence number series has been reset to a new value, clear RTP packet // history, since any packets there may conflict with new ones. - packet_history_.Clear(); + packet_history_->Clear(); } } @@ -782,7 +799,8 @@ std::unique_ptr RTPSender::BuildRtxPacket( } uint32_t RTPSender::BitrateSent() const { - return egress_.SendBitrate().bps(); + RTC_DCHECK(egress_); + return egress_->SendBitrate().bps(); } void RTPSender::SetRtpState(const RtpState& rtp_state) { @@ -794,7 +812,9 @@ void RTPSender::SetRtpState(const RtpState& rtp_state) { capture_time_ms_ = rtp_state.capture_time_ms; last_timestamp_time_ms_ = rtp_state.last_timestamp_time_ms; ssrc_has_acked_ = rtp_state.ssrc_has_acked; - egress_.SetMediaHasBeenSent(rtp_state.media_has_been_sent); + if (egress_) { + egress_->SetMediaHasBeenSent(rtp_state.media_has_been_sent); + } } RtpState RTPSender::GetRtpState() const { @@ -806,8 +826,10 @@ RtpState RTPSender::GetRtpState() const { state.timestamp = last_rtp_timestamp_; state.capture_time_ms = capture_time_ms_; state.last_timestamp_time_ms = last_timestamp_time_ms_; - state.media_has_been_sent = egress_.MediaHasBeenSent(); state.ssrc_has_acked = ssrc_has_acked_; + if (egress_) { + state.media_has_been_sent = egress_->MediaHasBeenSent(); + } return state; } @@ -835,11 +857,11 @@ int64_t RTPSender::LastTimestampTimeMs() const { } void RTPSender::SetRtt(int64_t rtt_ms) { - packet_history_.SetRtt(rtt_ms); + packet_history_->SetRtt(rtt_ms); } void RTPSender::OnPacketsAcknowledged( rtc::ArrayView sequence_numbers) { - packet_history_.CullAcknowledgedPackets(sequence_numbers); + packet_history_->CullAcknowledgedPackets(sequence_numbers); } } // namespace webrtc diff --git a/modules/rtp_rtcp/source/rtp_sender.h b/modules/rtp_rtcp/source/rtp_sender.h index c973c7ef64..5a87b377b1 100644 --- a/modules/rtp_rtcp/source/rtp_sender.h +++ b/modules/rtp_rtcp/source/rtp_sender.h @@ -47,21 +47,23 @@ class RtpPacketToSend; class RTPSender { public: + RTPSender(const RtpRtcp::Configuration& config, + RtpPacketHistory* packet_history, + RtpPacketSender* packet_sender); explicit RTPSender(const RtpRtcp::Configuration& config); ~RTPSender(); + // TODO(bugs.webrtc.org/11036): Remove. void ProcessBitrate(); - uint16_t ActualSendBitrateKbit() const; - uint32_t NackOverheadRate() const; void SetSendingMediaStatus(bool enabled); bool SendingMedia() const; + // TODO(bugs.webrtc.org/11036): Remove. void SetAsPartOfAllocation(bool part_of_allocation); - void GetDataCounters(StreamDataCounters* rtp_stats, StreamDataCounters* rtx_stats) const; @@ -91,13 +93,21 @@ class RTPSender { // Tries to send packet to transport. Also updates any timing extensions, // calls observers waiting for packet send events, and updates stats. // Returns true if packet belongs to this RTP module, false otherwise. + // TODO(bugs.webrtc.org/11036): Remove. bool TrySendPacket(RtpPacketToSend* packet, const PacedPacketInfo& pacing_info); + bool SupportsPadding() const; bool SupportsRtxPayloadPadding() const; + + // TODO(bugs.webrtc.org/11036): Remove. std::vector> GeneratePadding( size_t target_size_bytes); + std::vector> GeneratePadding( + size_t target_size_bytes, + bool media_has_been_sent); + // NACK. void OnReceivedNack(const std::vector& nack_sequence_numbers, int64_t avg_rtt); @@ -151,6 +161,7 @@ class RTPSender { // sending to the network. void EnqueuePackets(std::vector> packets); + // TODO(bugs.webrtc.org/11036): Remove. uint32_t BitrateSent() const; void SetRtpState(const RtpState& rtp_state); @@ -160,26 +171,11 @@ class RTPSender { int64_t LastTimestampTimeMs() const; + // TODO(bugs.webrtc.org/11036): Remove. void SetRtt(int64_t rtt_ms); - void OnPacketsAcknowledged(rtc::ArrayView sequence_numbers); private: - // Helper class that redirects packets directly to the send part of this class - // without passing through an actual paced sender. - class NonPacedPacketSender : public RtpPacketSender { - public: - explicit NonPacedPacketSender(RTPSender* rtp_sender); - virtual ~NonPacedPacketSender(); - - void EnqueuePackets( - std::vector> packets) override; - - private: - uint16_t transport_sequence_number_; - RTPSender* const rtp_sender_; - }; - std::unique_ptr BuildRtxPacket( const RtpPacketToSend& packet); @@ -194,8 +190,18 @@ class RTPSender { const absl::optional rtx_ssrc_; const absl::optional flexfec_ssrc_; - const std::unique_ptr non_paced_packet_sender_; - RtpPacketSender* const paced_sender_; + // TODO(bugs.webrtc.org/11036): Remove |owned_history_|, make + // |packet_history_| ptr const. + std::unique_ptr owned_history_; + RtpPacketHistory* packet_history_; + + // TODO(bugs.webrtc.org/11036): Remove |egress_| and |non_paced_sender_|, + // make |paced_sender_| ptr const. + std::unique_ptr egress_; + std::unique_ptr + non_paced_packet_sender_; + RtpPacketSender* paced_sender_; + rtc::CriticalSection send_critsect_; bool sending_media_ RTC_GUARDED_BY(send_critsect_); @@ -206,8 +212,6 @@ class RTPSender { RtpHeaderExtensionMap rtp_header_extension_map_ RTC_GUARDED_BY(send_critsect_); - RtpPacketHistory packet_history_; - // RTP variables uint32_t timestamp_offset_ RTC_GUARDED_BY(send_critsect_); bool sequence_number_forced_ RTC_GUARDED_BY(send_critsect_); @@ -233,8 +237,6 @@ class RTPSender { RateLimiter* const retransmission_rate_limiter_; - RtpSenderEgress egress_; - RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender); }; diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.cc b/modules/rtp_rtcp/source/rtp_sender_audio.cc index f93715addd..190bbd2afd 100644 --- a/modules/rtp_rtcp/source/rtp_sender_audio.cc +++ b/modules/rtp_rtcp/source/rtp_sender_audio.cc @@ -17,7 +17,6 @@ #include "absl/strings/match.h" #include "api/audio_codecs/audio_format.h" -#include "modules/remote_bitrate_estimator/test/bwe_test_logging.h" #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" #include "modules/rtp_rtcp/source/byte_io.h" #include "modules/rtp_rtcp/source/rtp_header_extensions.h" @@ -258,7 +257,7 @@ bool RTPSenderAudio::SendAudio(AudioFrameType frame_type, packet->SequenceNumber()); packet->set_packet_type(RtpPacketToSend::Type::kAudio); packet->set_allow_retransmission(true); - bool send_result = LogAndSendToNetwork(std::move(packet)); + bool send_result = rtp_sender_->SendToNetwork(std::move(packet)); if (first_packet_sent_()) { RTC_LOG(LS_INFO) << "First audio RTP packet sent to pacer"; } @@ -343,25 +342,10 @@ bool RTPSenderAudio::SendTelephoneEventPacket(bool ended, packet->set_packet_type(RtpPacketToSend::Type::kAudio); packet->set_allow_retransmission(true); - result = LogAndSendToNetwork(std::move(packet)); + result = rtp_sender_->SendToNetwork(std::move(packet)); send_count--; } while (send_count > 0 && result); return result; } - -bool RTPSenderAudio::LogAndSendToNetwork( - std::unique_ptr packet) { -#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE - int64_t now_ms = clock_->TimeInMilliseconds(); - BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioTotBitrate_kbps", now_ms, - rtp_sender_->ActualSendBitrateKbit(), - packet->Ssrc()); - BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioNackBitrate_kbps", now_ms, - rtp_sender_->NackOverheadRate() / 1000, - packet->Ssrc()); -#endif - return rtp_sender_->SendToNetwork(std::move(packet)); -} - } // namespace webrtc diff --git a/modules/rtp_rtcp/source/rtp_sender_audio.h b/modules/rtp_rtcp/source/rtp_sender_audio.h index c846d81daf..ccc26371aa 100644 --- a/modules/rtp_rtcp/source/rtp_sender_audio.h +++ b/modules/rtp_rtcp/source/rtp_sender_audio.h @@ -63,8 +63,6 @@ class RTPSenderAudio { bool MarkerBit(AudioFrameType frame_type, int8_t payload_type); private: - bool LogAndSendToNetwork(std::unique_ptr packet); - Clock* const clock_ = nullptr; RTPSender* const rtp_sender_ = nullptr; diff --git a/modules/rtp_rtcp/source/rtp_sender_egress.cc b/modules/rtp_rtcp/source/rtp_sender_egress.cc index 3782f7c7a5..b602eb6c1e 100644 --- a/modules/rtp_rtcp/source/rtp_sender_egress.cc +++ b/modules/rtp_rtcp/source/rtp_sender_egress.cc @@ -17,6 +17,7 @@ #include "absl/strings/match.h" #include "api/transport/field_trial_based_config.h" #include "logging/rtc_event_log/events/rtc_event_rtp_packet_outgoing.h" +#include "modules/remote_bitrate_estimator/test/bwe_test_logging.h" #include "rtc_base/logging.h" namespace webrtc { @@ -33,9 +34,26 @@ bool IsEnabled(absl::string_view name, } } // namespace +RtpSenderEgress::NonPacedPacketSender::NonPacedPacketSender( + RtpSenderEgress* sender) + : transport_sequence_number_(0), sender_(sender) {} +RtpSenderEgress::NonPacedPacketSender::~NonPacedPacketSender() = default; + +void RtpSenderEgress::NonPacedPacketSender::EnqueuePackets( + std::vector> packets) { + for (auto& packet : packets) { + if (!packet->SetExtension( + ++transport_sequence_number_)) { + --transport_sequence_number_; + } + packet->ReserveExtension(); + packet->ReserveExtension(); + sender_->SendPacket(packet.get(), PacedPacketInfo()); + } +} + RtpSenderEgress::RtpSenderEgress(const RtpRtcp::Configuration& config, - RtpPacketHistory* packet_history, - Clock* clock) + RtpPacketHistory* packet_history) : ssrc_(config.local_media_ssrc), rtx_ssrc_(config.rtx_send_ssrc), flexfec_ssrc_(config.flexfec_sender @@ -44,10 +62,11 @@ RtpSenderEgress::RtpSenderEgress(const RtpRtcp::Configuration& config, populate_network2_timestamp_(config.populate_network2_timestamp), send_side_bwe_with_overhead_( IsEnabled("WebRTC-SendSideBwe-WithOverhead", config.field_trials)), - clock_(clock), + clock_(config.clock), packet_history_(packet_history), transport_(config.outgoing_transport), event_log_(config.event_log), + is_audio_(config.audio), transport_feedback_observer_(config.transport_feedback_callback), send_side_delay_observer_(config.send_side_delay_observer), send_packet_observer_(config.send_packet_observer), @@ -72,6 +91,23 @@ void RtpSenderEgress::SendPacket(RtpPacketToSend* packet, const uint32_t packet_ssrc = packet->Ssrc(); RTC_DCHECK(packet->packet_type().has_value()); RTC_DCHECK(HasCorrectSsrc(*packet)); + int64_t now_ms = clock_->TimeInMilliseconds(); + + if (is_audio_) { +#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioTotBitrate_kbps", now_ms, + SendBitrate().kbps(), packet_ssrc); + BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "AudioNackBitrate_kbps", now_ms, + NackOverheadRate().kbps(), packet_ssrc); +#endif + } else { +#if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE + BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoTotBitrate_kbps", now_ms, + SendBitrate().kbps(), packet_ssrc); + BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoNackBitrate_kbps", now_ms, + NackOverheadRate().kbps(), packet_ssrc); +#endif + } PacketOptions options; { @@ -87,7 +123,6 @@ void RtpSenderEgress::SendPacket(RtpPacketToSend* packet, // In case of VideoTimingExtension, since it's present not in every packet, // data after rtp header may be corrupted if these packets are protected by // the FEC. - int64_t now_ms = clock_->TimeInMilliseconds(); int64_t diff_ms = now_ms - packet->capture_time_ms(); if (packet->IsExtensionReserved()) { packet->SetExtension(kTimestampTicksPerMs * diff_ms); diff --git a/modules/rtp_rtcp/source/rtp_sender_egress.h b/modules/rtp_rtcp/source/rtp_sender_egress.h index baa2227ca1..e72a0cff67 100644 --- a/modules/rtp_rtcp/source/rtp_sender_egress.h +++ b/modules/rtp_rtcp/source/rtp_sender_egress.h @@ -12,6 +12,8 @@ #define MODULES_RTP_RTCP_SOURCE_RTP_SENDER_EGRESS_H_ #include +#include +#include #include "absl/types/optional.h" #include "api/call/transport.h" @@ -29,9 +31,23 @@ namespace webrtc { class RtpSenderEgress { public: - explicit RtpSenderEgress(const RtpRtcp::Configuration& config, - RtpPacketHistory* packet_history, - Clock* clock); + // Helper class that redirects packets directly to the send part of this class + // without passing through an actual paced sender. + class NonPacedPacketSender : public RtpPacketSender { + public: + explicit NonPacedPacketSender(RtpSenderEgress* sender); + virtual ~NonPacedPacketSender(); + + void EnqueuePackets( + std::vector> packets) override; + + private: + uint16_t transport_sequence_number_; + RtpSenderEgress* const sender_; + }; + + RtpSenderEgress(const RtpRtcp::Configuration& config, + RtpPacketHistory* packet_history); ~RtpSenderEgress() = default; void SendPacket(RtpPacketToSend* packet, const PacedPacketInfo& pacing_info); @@ -83,6 +99,7 @@ class RtpSenderEgress { RtpPacketHistory* const packet_history_; Transport* const transport_; RtcEventLog* const event_log_; + const bool is_audio_; TransportFeedbackObserver* const transport_feedback_observer_; SendSideDelayObserver* const send_side_delay_observer_; diff --git a/modules/rtp_rtcp/source/rtp_sender_video.cc b/modules/rtp_rtcp/source/rtp_sender_video.cc index c0cda4be78..236dd340c6 100644 --- a/modules/rtp_rtcp/source/rtp_sender_video.cc +++ b/modules/rtp_rtcp/source/rtp_sender_video.cc @@ -339,14 +339,12 @@ void RTPSenderVideo::LogAndSendToNetwork( int64_t now_ms = clock_->TimeInMilliseconds(); #if BWE_TEST_LOGGING_COMPILE_TIME_ENABLE for (const auto& packet : packets) { - const uint32_t ssrc = packet->Ssrc(); - BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoTotBitrate_kbps", now_ms, - rtp_sender_->ActualSendBitrateKbit(), ssrc); - BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoFecBitrate_kbps", now_ms, - FecOverheadRate() / 1000, ssrc); - BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoNackBitrate_kbps", now_ms, - rtp_sender_->NackOverheadRate() / 1000, - ssrc); + if (packet->packet_type() == + RtpPacketToSend::Type::kForwardErrorCorrection) { + const uint32_t ssrc = packet->Ssrc(); + BWE_TEST_LOGGING_PLOT_WITH_SSRC(1, "VideoFecBitrate_kbps", now_ms, + FecOverheadRate() / 1000, ssrc); + } } #endif