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