Correcting the amount of padding when send side bwe includes RTP overhead.

webrtc/modules/rtp_rtcp/source/rtp_sender.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 424 matching lines @@
     rtc::CritScope lock(&send_critsect_);
     if (!sending_media_)
       return 0;
     if ((rtx_ & kRtxRedundantPayloads) == 0)
       return 0;
   }
 
   int bytes_left = static_cast<int>(bytes_to_send);
   while (bytes_left > 0) {
     std::unique_ptr<RtpPacketToSend> packet =
-        packet_history_.GetBestFittingPacket(bytes_left);
+        packet_history_.GetBestFittingPacket(bytes_left,
+                                             send_side_bwe_with_overhead_);
     if (!packet)
       break;
-    size_t payload_size = packet->payload_size();
+    // When WebRTC-SendSideBwe-WithOverhead is enabled, the padding budget
+    // includes overhead.
+    const size_t used_bytes =
+        send_side_bwe_with_overhead_
+            ? packet->payload_size() + packet->headers_size()
+            : packet->payload_size();
     if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
       break;
-    bytes_left -= payload_size;
+    bytes_left -= used_bytes;
   }
   return bytes_to_send - bytes_left;
 }
 
 size_t RTPSender::SendPadData(size_t bytes,
                               const PacedPacketInfo& pacing_info) {
-  size_t padding_bytes_in_packet;
+  // Always send full padding packets. This is accounted for by the
+  // RtpPacketSender, which will make sure we don't send too much padding even
+  // if a single packet is larger than requested.
+  // We do this to avoid frequently sending small packets on higher bitrates.
+  size_t padding_bytes_in_packet =
+      std::min(MaxPayloadSize(), kMaxPaddingLength);
+
   if (audio_configured_) {
     // Allow smaller padding packets for audio.
+
+    // When WebRTC-SendSideBwe-WithOverhead is enabled, the padding budget
+    // includes overhead.
+    const size_t padding_bytes_if_one_packet =
+        send_side_bwe_with_overhead_
+            ? std::max<int>(0, bytes - RtpHeaderLength())
+            : bytes;
     padding_bytes_in_packet =
-        std::min(std::max(bytes, kMinAudioPaddingLength), MaxPayloadSize());
-    if (padding_bytes_in_packet > kMaxPaddingLength)
-      padding_bytes_in_packet = kMaxPaddingLength;
-  } else {
-    // Always send full padding packets. This is accounted for by the
-    // RtpPacketSender, which will make sure we don't send too much padding even
-    // if a single packet is larger than requested.
-    // We do this to avoid frequently sending small packets on higher bitrates.
-    padding_bytes_in_packet = std::min(MaxPayloadSize(), kMaxPaddingLength);
+        std::min(padding_bytes_in_packet,
+                 std::max(padding_bytes_if_one_packet, kMinAudioPaddingLength));
   }
+
   size_t bytes_sent = 0;
   while (bytes_sent < bytes) {
     int64_t now_ms = clock_->TimeInMilliseconds();
     uint32_t ssrc;
     uint32_t timestamp;
     int64_t capture_time_ms;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
@@ skipping 64 matching lines @@
     padding_packet.SetSsrc(ssrc);
 
     if (capture_time_ms > 0) {
       padding_packet.SetExtension<TransmissionOffset>(
           (now_ms - capture_time_ms) * kTimestampTicksPerMs);
     }
     padding_packet.SetExtension<AbsoluteSendTime>(now_ms);
     PacketOptions options;
     bool has_transport_seq_num =
         UpdateTransportSequenceNumber(&padding_packet, &options.packet_id);
+
     padding_packet.SetPadding(padding_bytes_in_packet, &random_);
 
     if (has_transport_seq_num) {
       AddPacketToTransportFeedback(options.packet_id, padding_packet,
                                    pacing_info);
     }
 
     if (!SendPacketToNetwork(padding_packet, options, pacing_info))
       break;
 
-    bytes_sent += padding_bytes_in_packet;
+    // When WebRTC-SendSideBwe-WithOverhead is enabled, the padding budget
+    // includes overhead.
+    bytes_sent +=
+        send_side_bwe_with_overhead_
+            ? padding_packet.padding_size() + padding_packet.headers_size()
+            : padding_packet.padding_size();
     UpdateRtpStats(padding_packet, over_rtx, false);
   }
 
   return bytes_sent;
 }
 
 void RTPSender::SetStorePacketsStatus(bool enable, uint16_t number_to_store) {
   packet_history_.SetStorePacketsStatus(enable, number_to_store);
 }
 
@@ skipping 13 matching lines @@
   // TODO(sprang): Add histograms for nack success or failure reasons.
   RTC_DCHECK(retransmission_rate_limiter_);
   if (!retransmission_rate_limiter_->TryUseRate(packet->size()))
     return -1;
 
   if (paced_sender_) {
     // Convert from TickTime to Clock since capture_time_ms is based on
     // TickTime.
     int64_t corrected_capture_tims_ms =
         packet->capture_time_ms() + clock_delta_ms_;
+    const size_t packet_size =
+        send_side_bwe_with_overhead_
+            ? packet->payload_size() + packet->headers_size()
+            : packet->payload_size();
     paced_sender_->InsertPacket(RtpPacketSender::kNormalPriority,
                                 packet->Ssrc(), packet->SequenceNumber(),
-                                corrected_capture_tims_ms,
-                                packet->payload_size(), true);
+                                corrected_capture_tims_ms, packet_size, true);
 
     return packet->size();
   }
   bool rtx = (RtxStatus() & kRtxRetransmitted) > 0;
   int32_t packet_size = static_cast<int32_t>(packet->size());
   if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
     return -1;
   return packet_size;
 }
 
@@ skipping 221 matching lines @@
                                     NackOverheadRate() / 1000, packet->Ssrc());
   }
 
   uint32_t ssrc = packet->Ssrc();
   rtc::Optional<uint32_t> flexfec_ssrc = FlexfecSsrc();
   if (paced_sender_) {
     uint16_t seq_no = packet->SequenceNumber();
     // Correct offset between implementations of millisecond time stamps in
     // TickTime and Clock.
     int64_t corrected_time_ms = packet->capture_time_ms() + clock_delta_ms_;
-    size_t payload_length = packet->payload_size();
+    const size_t packet_size =
+        send_side_bwe_with_overhead_
+            ? packet->payload_size() + packet->headers_size()
+            : packet->payload_size();
     if (ssrc == flexfec_ssrc) {
       // Store FlexFEC packets in the history here, so they can be found
       // when the pacer calls TimeToSendPacket.
       flexfec_packet_history_.PutRtpPacket(std::move(packet), storage, false);
     } else {
       packet_history_.PutRtpPacket(std::move(packet), storage, false);
     }
 
     paced_sender_->InsertPacket(priority, ssrc, seq_no, corrected_time_ms,
-                                payload_length, false);
+                                packet_size, false);
+
     if (last_capture_time_ms_sent_ == 0 ||
         corrected_time_ms > last_capture_time_ms_sent_) {
       last_capture_time_ms_sent_ = corrected_time_ms;
       TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                                "PacedSend", corrected_time_ms,
                                "capture_time_ms", corrected_time_ms);
     }
     return true;
   }
 
@@ skipping 364 matching lines @@
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = timestamp_offset_;
 
   return state;
 }
 
 void RTPSender::AddPacketToTransportFeedback(
     uint16_t packet_id,
     const RtpPacketToSend& packet,
     const PacedPacketInfo& pacing_info) {
-  size_t packet_size = packet.payload_size() + packet.padding_size();
-  if (send_side_bwe_with_overhead_) {
-    packet_size = packet.size();
-  }
-
+  const size_t packet_size =
+      send_side_bwe_with_overhead_
+          ? packet.size()
+          : packet.payload_size() + packet.padding_size();
   if (transport_feedback_observer_) {
     transport_feedback_observer_->AddPacket(SSRC(), packet_id, packet_size,
                                             pacing_info);
   }
 }
 
 void RTPSender::UpdateRtpOverhead(const RtpPacketToSend& packet) {
   if (!overhead_observer_)
     return;
   size_t overhead_bytes_per_packet;
   {
     rtc::CritScope lock(&send_critsect_);
     if (rtp_overhead_bytes_per_packet_ == packet.headers_size()) {
       return;
     }
     rtp_overhead_bytes_per_packet_ = packet.headers_size();
     overhead_bytes_per_packet = rtp_overhead_bytes_per_packet_;
   }
   overhead_observer_->OnOverheadChanged(overhead_bytes_per_packet);
 }
 
 }  // namespace webrtc