Enable probing with repeated payload packets by default.

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 551 matching lines @@
     if (!PrepareAndSendPacket(buffer, length, capture_time_ms, true, false))
       break;
     RtpUtility::RtpHeaderParser rtp_parser(buffer, length);
     RTPHeader rtp_header;
     rtp_parser.Parse(rtp_header);
     bytes_left -= static_cast<int>(length - rtp_header.headerLength);
   }
   return bytes_to_send - bytes_left;
 }
 
-size_t RTPSender::BuildPaddingPacket(uint8_t* packet, size_t header_length) {
-  size_t padding_bytes_in_packet = kMaxPaddingLength;
+void RTPSender::BuildPaddingPacket(uint8_t* packet,
+                                   size_t header_length,
+                                   size_t padding_length) {
   packet[0] |= 0x20;  // Set padding bit.
   int32_t *data =
       reinterpret_cast<int32_t *>(&(packet[header_length]));
 
   // Fill data buffer with random data.
-  for (size_t j = 0; j < (padding_bytes_in_packet >> 2); ++j) {
+  for (size_t j = 0; j < (padding_length >> 2); ++j) {
     data[j] = rand();  // NOLINT
   }
   // Set number of padding bytes in the last byte of the packet.
-  packet[header_length + padding_bytes_in_packet - 1] =
-      static_cast<uint8_t>(padding_bytes_in_packet);
-  return padding_bytes_in_packet;
+  packet[header_length + padding_length - 1] =
+      static_cast<uint8_t>(padding_length);
 }
 
-size_t RTPSender::TrySendPadData(size_t bytes) {
-  int64_t capture_time_ms;
-  uint32_t timestamp;
-  {
-    CriticalSectionScoped cs(send_critsect_.get());
-    timestamp = timestamp_;
-    capture_time_ms = capture_time_ms_;
-    if (last_timestamp_time_ms_ > 0) {
-      timestamp +=
-          (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90;
-      capture_time_ms +=
-          (clock_->TimeInMilliseconds() - last_timestamp_time_ms_);
-    }
-  }
-  return SendPadData(timestamp, capture_time_ms, bytes);
-}
-
-size_t RTPSender::SendPadData(uint32_t timestamp,
-                              int64_t capture_time_ms,
-                              size_t bytes) {
-  size_t padding_bytes_in_packet = 0;
+size_t RTPSender::SendPadData(size_t bytes,
+                              bool timestamp_provided,
+                              uint32_t timestamp,
+                              int64_t capture_time_ms) {
+  // Always send full padding packets. This is accounted for by the PacedSender,
+  // which will make sure we don't send too much padding even if a single packet
+  // is larger than requested.
+  size_t padding_bytes_in_packet =
+      std::min(MaxDataPayloadLength(), kMaxPaddingLength);
   size_t bytes_sent = 0;
   bool using_transport_seq = rtp_header_extension_map_.IsRegistered(
                                  kRtpExtensionTransportSequenceNumber) &&
                              packet_router_;
   for (; bytes > 0; bytes -= padding_bytes_in_packet) {
-    // Always send full padding packets.
-    if (bytes < kMaxPaddingLength)
-      bytes = kMaxPaddingLength;
+    if (bytes < padding_bytes_in_packet)
+      bytes = padding_bytes_in_packet;
 
     uint32_t ssrc;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
       CriticalSectionScoped cs(send_critsect_.get());
-      // Only send padding packets following the last packet of a frame,
-      // indicated by the marker bit.
+      if (!timestamp_provided) {
+        timestamp = timestamp_;
+        capture_time_ms = capture_time_ms_;
+        if (rtx_ != kRtxOff && last_timestamp_time_ms_ > 0) {
+          timestamp +=
+              (clock_->TimeInMilliseconds() - last_timestamp_time_ms_) * 90;
+          capture_time_ms +=
+              (clock_->TimeInMilliseconds() - last_timestamp_time_ms_);
+        }
+      }

[stefan-webrtc, 2015/09/10 11:40:33]

Moving this in here solves the race I explained offline.

       if (rtx_ == kRtxOff) {
         // Without RTX we can't send padding in the middle of frames.
         if (!last_packet_marker_bit_)
           return 0;
         ssrc = ssrc_;
         sequence_number = sequence_number_;
         ++sequence_number_;
         payload_type = payload_type_;
         over_rtx = false;
       } else {
         // Without abs-send-time a media packet must be sent before padding so
         // that the timestamps used for estimation are correct.
         if (!media_has_been_sent_ && !rtp_header_extension_map_.IsRegistered(
             kRtpExtensionAbsoluteSendTime))
           return 0;
         ssrc = ssrc_rtx_;
         sequence_number = sequence_number_rtx_;
         ++sequence_number_rtx_;
         payload_type = rtx_payload_type_;
         over_rtx = true;
       }
     }
 
     uint8_t padding_packet[IP_PACKET_SIZE];
     size_t header_length =
         CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp,
                         sequence_number, std::vector<uint32_t>());
-    assert(header_length != static_cast<size_t>(-1));
-    padding_bytes_in_packet = BuildPaddingPacket(padding_packet, header_length);
-    assert(padding_bytes_in_packet <= bytes);
+    BuildPaddingPacket(padding_packet, header_length, padding_bytes_in_packet);
     size_t length = padding_bytes_in_packet + header_length;
     int64_t now_ms = clock_->TimeInMilliseconds();
 
     RtpUtility::RtpHeaderParser rtp_parser(padding_packet, length);
     RTPHeader rtp_header;
     rtp_parser.Parse(rtp_header);
 
     if (capture_time_ms > 0) {
       UpdateTransmissionTimeOffset(
           padding_packet, length, rtp_header, now_ms - capture_time_ms);
@@ skipping 324 matching lines @@
 size_t RTPSender::TimeToSendPadding(size_t bytes) {
   if (bytes == 0)
     return 0;
   {
     CriticalSectionScoped cs(send_critsect_.get());
     if (!sending_media_)
       return 0;
   }
   size_t bytes_sent = TrySendRedundantPayloads(bytes);
   if (bytes_sent < bytes)
-    bytes_sent += TrySendPadData(bytes - bytes_sent);
+    bytes_sent += SendPadData(bytes - bytes_sent, false, 0, 0);
   return bytes_sent;
 }
 
 // TODO(pwestin): send in the RtpHeaderParser to avoid parsing it again.
 int32_t RTPSender::SendToNetwork(
     uint8_t *buffer, size_t payload_length, size_t rtp_header_length,
     int64_t capture_time_ms, StorageType storage,
     PacedSender::Priority priority) {
   RtpUtility::RtpHeaderParser rtp_parser(buffer,
                                          payload_length + rtp_header_length);
@@ skipping 887 matching lines @@
   CriticalSectionScoped lock(send_critsect_.get());
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc