From f3db34d06074bf777f50bbd5c9f16e95bd908053 Mon Sep 17 00:00:00 2001 From: Sebastian Jansson Date: Fri, 24 May 2019 07:34:00 +0000 Subject: [PATCH] Revert "Cleanup of video packet overhead calculation." MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit 890bc3069cbababa19b40ec02684253d60e051b2. Reason for revert: Div by zero. Original change's description: > Cleanup of video packet overhead calculation. > > This CL updates the video packet overhead calculation to make it more > clear. This prepares for future work on improving the accuracy of the > calculation. > > Bug: webrtc:9883 > Change-Id: I1d623a3e0de45be7b6e4a1f9e3cbe54fd2b8a45a > Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/138077 > Commit-Queue: Sebastian Jansson > Reviewed-by: Erik Språng > Cr-Commit-Position: refs/heads/master@{#28040} TBR=sprang@webrtc.org,srte@webrtc.org Change-Id: Icbdfc7b9252f8f9aa8e7e97b85b04171a27935e4 No-Presubmit: true No-Tree-Checks: true No-Try: true Bug: webrtc:9883 Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/138212 Reviewed-by: Sebastian Jansson Commit-Queue: Sebastian Jansson Cr-Commit-Position: refs/heads/master@{#28049} --- call/rtp_video_sender.cc | 59 ++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 26 deletions(-) diff --git a/call/rtp_video_sender.cc b/call/rtp_video_sender.cc index 115cd1f758..bd56c33668 100644 --- a/call/rtp_video_sender.cc +++ b/call/rtp_video_sender.cc @@ -188,13 +188,19 @@ std::unique_ptr MaybeCreateFlexfecSender( RTPSender::FecExtensionSizes(), rtp_state, clock); } -DataRate CalculateMinOverheadRate(DataRate bitrate, - DataSize overhead_per_packet, - DataSize max_packet_size) { - TimeDelta packet_interval = max_packet_size / bitrate; - int packets_per_second = - rtc::dchecked_cast(std::ceil(1 / packet_interval.seconds())); - return packets_per_second * overhead_per_packet / TimeDelta::Seconds<1>(); +uint32_t CalculateOverheadRateBps(int packets_per_second, + size_t overhead_bytes_per_packet, + uint32_t max_overhead_bps) { + uint32_t overhead_bps = + static_cast(8 * overhead_bytes_per_packet * packets_per_second); + return std::min(overhead_bps, max_overhead_bps); +} + +int CalculatePacketRate(uint32_t bitrate_bps, size_t packet_size_bytes) { + size_t packet_size_bits = 8 * packet_size_bytes; + // Ceil for int value of bitrate_bps / packet_size_bits. + return static_cast((bitrate_bps + packet_size_bits - 1) / + packet_size_bits); } } // namespace @@ -680,17 +686,16 @@ void RtpVideoSender::OnBitrateUpdated(uint32_t bitrate_bps, int framerate) { // Substract overhead from bitrate. rtc::CritScope lock(&crit_); - DataSize packet_overhead = DataSize::bytes( - overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_); - DataSize max_total_packet_size = DataSize::bytes( - rtp_config_.max_packet_size + transport_overhead_bytes_per_packet_); uint32_t payload_bitrate_bps = bitrate_bps; if (send_side_bwe_with_overhead_) { - DataRate overhead_rate = CalculateMinOverheadRate( - DataRate::bps(bitrate_bps), packet_overhead, max_total_packet_size); - // TODO(srte): We probably should not accept 0 payload bitrate here. - payload_bitrate_bps = - rtc::saturated_cast(bitrate_bps - overhead_rate.bps()); + uint32_t overhead_bps = CalculateOverheadRateBps( + CalculatePacketRate( + bitrate_bps, + rtp_config_.max_packet_size + transport_overhead_bytes_per_packet_), + overhead_bytes_per_packet_ + transport_overhead_bytes_per_packet_, + bitrate_bps); + RTC_DCHECK_LE(overhead_bps, bitrate_bps); + payload_bitrate_bps = bitrate_bps - overhead_bps; } // Get the encoder target rate. It is the estimated network rate - @@ -711,16 +716,18 @@ void RtpVideoSender::OnBitrateUpdated(uint32_t bitrate_bps, loss_mask_vector_.clear(); - uint32_t encoder_overhead_rate_bps = 0; - if (send_side_bwe_with_overhead_) { - // TODO(srte): The packet size should probably match the one used above. - DataRate encoder_overhead_rate = CalculateMinOverheadRate( - DataRate::bps(encoder_target_rate_bps_), packet_overhead, - max_total_packet_size - DataSize::bytes(overhead_bytes_per_packet_)); - encoder_overhead_rate_bps = - std::min(encoder_overhead_rate.bps(), - bitrate_bps - encoder_target_rate_bps_); - } + uint32_t encoder_overhead_rate_bps = + send_side_bwe_with_overhead_ + ? CalculateOverheadRateBps( + CalculatePacketRate(encoder_target_rate_bps_, + rtp_config_.max_packet_size + + transport_overhead_bytes_per_packet_ - + overhead_bytes_per_packet_), + overhead_bytes_per_packet_ + + transport_overhead_bytes_per_packet_, + bitrate_bps - encoder_target_rate_bps_) + : 0; + // When the field trial "WebRTC-SendSideBwe-WithOverhead" is enabled // protection_bitrate includes overhead. const uint32_t media_rate = encoder_target_rate_bps_ +