Propagate packet pacing information to SendTimeHistory.

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 430 matching lines @@
     ++frame_counts_.delta_frames;
   }
   if (frame_count_observer_) {
     frame_count_observer_->FrameCountUpdated(frame_counts_, ssrc);
   }
 
   return result;
 }
 
 size_t RTPSender::TrySendRedundantPayloads(size_t bytes_to_send,
-                                           int probe_cluster_id) {
+                                           const PacedPacketInfo& pacing_info) {
   {
     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);
     if (!packet)
       break;
     size_t payload_size = packet->payload_size();
-    if (!PrepareAndSendPacket(std::move(packet), true, false, probe_cluster_id))
+    if (!PrepareAndSendPacket(std::move(packet), true, false, pacing_info))
       break;
     bytes_left -= payload_size;
   }
   return bytes_to_send - bytes_left;
 }
 
-size_t RTPSender::SendPadData(size_t bytes, int probe_cluster_id) {
+size_t RTPSender::SendPadData(size_t bytes,
+                              const PacedPacketInfo& pacing_info) {
   size_t padding_bytes_in_packet;
   if (audio_configured_) {
     // Allow smaller padding packets for audio.
     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
@@ skipping 82 matching lines @@
           (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,
-                                   probe_cluster_id);
+                                   pacing_info);
     }
 
     if (!SendPacketToNetwork(padding_packet, options))
       break;
 
     bytes_sent += padding_bytes_in_packet;
     UpdateRtpStats(padding_packet, over_rtx, false);
   }
 
   return bytes_sent;
@@ skipping 28 matching lines @@
         packet->capture_time_ms() + clock_delta_ms_;
     paced_sender_->InsertPacket(RtpPacketSender::kNormalPriority,
                                 packet->Ssrc(), packet->SequenceNumber(),
                                 corrected_capture_tims_ms,
                                 packet->payload_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::kNotAProbe))
+  if (!PrepareAndSendPacket(std::move(packet), rtx, true, PacedPacketInfo()))
     return -1;
   return packet_size;
 }
 
 bool RTPSender::SendPacketToNetwork(const RtpPacketToSend& packet,
                                     const PacketOptions& options) {
   int bytes_sent = -1;
   if (transport_) {
     UpdateRtpOverhead(packet);
     bytes_sent = transport_->SendRtp(packet.data(), packet.size(), options)
@@ skipping 48 matching lines @@
 void RTPSender::OnReceivedRtcpReportBlocks(
     const ReportBlockList& report_blocks) {
   playout_delay_oracle_.OnReceivedRtcpReportBlocks(report_blocks);
 }
 
 // Called from pacer when we can send the packet.
 bool RTPSender::TimeToSendPacket(uint32_t ssrc,
                                  uint16_t sequence_number,
                                  int64_t capture_time_ms,
                                  bool retransmission,
-                                 int probe_cluster_id) {
+                                 const PacedPacketInfo& pacing_info) {
   if (!SendingMedia())
     return true;
 
   std::unique_ptr<RtpPacketToSend> packet;
   if (ssrc == SSRC()) {
     packet = packet_history_.GetPacketAndSetSendTime(sequence_number, 0,
                                                      retransmission);
   } else if (ssrc == FlexfecSsrc()) {
     packet = flexfec_packet_history_.GetPacketAndSetSendTime(sequence_number, 0,
                                                              retransmission);
   }
 
   if (!packet) {
     // Packet cannot be found.
     return true;
   }
 
   return PrepareAndSendPacket(
       std::move(packet),
       retransmission && (RtxStatus() & kRtxRetransmitted) > 0, retransmission,
-      probe_cluster_id);
+      pacing_info);
 }
 
 bool RTPSender::PrepareAndSendPacket(std::unique_ptr<RtpPacketToSend> packet,
                                      bool send_over_rtx,
                                      bool is_retransmit,
-                                     int probe_cluster_id) {
+                                     const PacedPacketInfo& pacing_info) {
   RTC_DCHECK(packet);
   int64_t capture_time_ms = packet->capture_time_ms();
   RtpPacketToSend* packet_to_send = packet.get();
 
   if (!is_retransmit && packet->Marker()) {
     TRACE_EVENT_ASYNC_END0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PacedSend",
                            capture_time_ms);
   }
 
   TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
@@ skipping 10 matching lines @@
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   int64_t diff_ms = now_ms - capture_time_ms;
   packet_to_send->SetExtension<TransmissionOffset>(kTimestampTicksPerMs *
                                                    diff_ms);
   packet_to_send->SetExtension<AbsoluteSendTime>(now_ms);
 
   PacketOptions options;
   if (UpdateTransportSequenceNumber(packet_to_send, &options.packet_id)) {
     AddPacketToTransportFeedback(options.packet_id, *packet_to_send,
-                                 probe_cluster_id);
+                                 pacing_info);
   }
 
   if (!is_retransmit && !send_over_rtx) {
     UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
     UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
                        packet->Ssrc());
   }
 
   if (!SendPacketToNetwork(*packet_to_send, options))
     return false;
@@ skipping 41 matching lines @@
     return true;
 
   // RED+ULPFEC.
   int pt_red;
   int pt_fec;
   video_->GetUlpfecConfig(&pt_red, &pt_fec);
   return static_cast<int>(packet.PayloadType()) == pt_red &&
          static_cast<int>(packet.payload()[0]) == pt_fec;
 }
 
-size_t RTPSender::TimeToSendPadding(size_t bytes, int probe_cluster_id) {
+size_t RTPSender::TimeToSendPadding(size_t bytes,
+                                    const PacedPacketInfo& pacing_info) {
   if (bytes == 0)
     return 0;
-  size_t bytes_sent = TrySendRedundantPayloads(bytes, probe_cluster_id);
+  size_t bytes_sent = TrySendRedundantPayloads(bytes, pacing_info);
   if (bytes_sent < bytes)
-    bytes_sent += SendPadData(bytes - bytes_sent, probe_cluster_id);
+    bytes_sent += SendPadData(bytes - bytes_sent, pacing_info);
   return bytes_sent;
 }
 
 bool RTPSender::SendToNetwork(std::unique_ptr<RtpPacketToSend> packet,
                               StorageType storage,
                               RtpPacketSender::Priority priority) {
   RTC_DCHECK(packet);
   int64_t now_ms = clock_->TimeInMilliseconds();
 
   // |capture_time_ms| <= 0 is considered invalid.
@@ skipping 43 matching lines @@
       TRACE_EVENT_ASYNC_BEGIN1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"),
                                "PacedSend", corrected_time_ms,
                                "capture_time_ms", corrected_time_ms);
     }
     return true;
   }
 
   PacketOptions options;
   if (UpdateTransportSequenceNumber(packet.get(), &options.packet_id)) {
     AddPacketToTransportFeedback(options.packet_id, *packet.get(),
-                                 PacedPacketInfo::kNotAProbe);
+                                 PacedPacketInfo());
   }
 
   UpdateDelayStatistics(packet->capture_time_ms(), now_ms);
   UpdateOnSendPacket(options.packet_id, packet->capture_time_ms(),
                      packet->Ssrc());
 
   bool sent = SendPacketToNetwork(*packet, options);
 
   if (sent) {
     {
@@ skipping 346 matching lines @@
 RtpState RTPSender::GetRtxRtpState() const {
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = timestamp_offset_;
 
   return state;
 }
 
-void RTPSender::AddPacketToTransportFeedback(uint16_t packet_id,
-                                             const RtpPacketToSend& packet,
-                                             int probe_cluster_id) {
+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();
   }
 
   if (transport_feedback_observer_) {
     transport_feedback_observer_->AddPacket(packet_id, packet_size,
-                                            probe_cluster_id);
+                                            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