Fix bug where transport sequence numbers are allocated for packets without the header extension reg…

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 573 matching lines @@
                               uint32_t timestamp,
                               int64_t capture_time_ms,
                               int probe_cluster_id) {
   // 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.
   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) &&
-                             transport_sequence_number_allocator_;
+  bool using_transport_seq =
+      IsRtpHeaderExtensionRegistered(kRtpExtensionTransportSequenceNumber) &&
+      transport_sequence_number_allocator_;
   for (; bytes > 0; bytes -= padding_bytes_in_packet) {
     if (bytes < padding_bytes_in_packet)
       bytes = padding_bytes_in_packet;
 
     uint32_t ssrc;
     uint16_t sequence_number;
     int payload_type;
     bool over_rtx;
     {
       rtc::CritScope lock(&send_critsect_);
@@ skipping 33 matching lines @@
         }
         ssrc = ssrc_rtx_;
         sequence_number = sequence_number_rtx_;
         ++sequence_number_rtx_;
         payload_type = rtx_payload_type_map_.begin()->second;
         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>());
+    size_t header_length = 0;
+    {
+      rtc::CritScope lock(&send_critsect_);
+      header_length =
+          CreateRtpHeader(padding_packet, payload_type, ssrc, false, timestamp,
+                          sequence_number, std::vector<uint32_t>());
+    }
     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);
     }
 
     UpdateAbsoluteSendTime(padding_packet, length, rtp_header, now_ms);
 
     PacketOptions options;
-    if (AllocateTransportSequenceNumber(&options.packet_id)) {
-      if (UpdateTransportSequenceNumber(options.packet_id, padding_packet,
-                                        length, rtp_header)) {
-        if (transport_feedback_observer_)
-          transport_feedback_observer_->AddPacket(options.packet_id, length,
-                                                  probe_cluster_id);
-      }
+    if (UpdateTransportSequenceNumber(padding_packet, length, rtp_header,
+                                      &options.packet_id)) {
+      if (transport_feedback_observer_)
+        transport_feedback_observer_->AddPacket(options.packet_id, length,
+                                                probe_cluster_id);
     }
 
     if (!SendPacketToNetwork(padding_packet, length, options))
       break;
 
     bytes_sent += padding_bytes_in_packet;
     UpdateRtpStats(padding_packet, length, rtp_header, over_rtx, false);
   }
 
   return bytes_sent;
@@ skipping 166 matching lines @@
     buffer_to_send_ptr = data_buffer_rtx;
   }
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   int64_t diff_ms = now_ms - capture_time_ms;
   UpdateTransmissionTimeOffset(buffer_to_send_ptr, length, rtp_header,
                                diff_ms);
   UpdateAbsoluteSendTime(buffer_to_send_ptr, length, rtp_header, now_ms);
 
   PacketOptions options;
-  if (AllocateTransportSequenceNumber(&options.packet_id)) {
-    if (UpdateTransportSequenceNumber(options.packet_id, buffer_to_send_ptr,
-                                      length, rtp_header)) {
-      if (transport_feedback_observer_)
-        transport_feedback_observer_->AddPacket(options.packet_id, length,
-                                                probe_cluster_id);
-    }
+  if (UpdateTransportSequenceNumber(buffer_to_send_ptr, length, rtp_header,
+                                    &options.packet_id)) {
+    if (transport_feedback_observer_)
+      transport_feedback_observer_->AddPacket(options.packet_id, length,
+                                              probe_cluster_id);
   }
 
   if (!is_retransmit && !send_over_rtx) {
     UpdateDelayStatistics(capture_time_ms, now_ms);
     UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc);
   }
 
   bool ret = SendPacketToNetwork(buffer_to_send_ptr, length, options);
   if (ret) {
     rtc::CritScope lock(&send_critsect_);
@@ skipping 106 matching lines @@
         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 0;
   }
 
   PacketOptions options;
-  if (AllocateTransportSequenceNumber(&options.packet_id)) {
-    if (UpdateTransportSequenceNumber(options.packet_id, buffer, length,
-                                      rtp_header)) {
-      if (transport_feedback_observer_)
-        transport_feedback_observer_->AddPacket(options.packet_id, length,
-                                                PacketInfo::kNotAProbe);
-    }
+  if (UpdateTransportSequenceNumber(buffer, length, rtp_header,
+                                    &options.packet_id)) {
+    if (transport_feedback_observer_)
+      transport_feedback_observer_->AddPacket(options.packet_id, length,
+                                              PacketInfo::kNotAProbe);
   }
   UpdateDelayStatistics(capture_time_ms, now_ms);
   UpdateOnSendPacket(options.packet_id, capture_time_ms, rtp_header.ssrc);
 
   bool sent = SendPacketToNetwork(buffer, length, options);
 
   // Mark the packet as sent in the history even if send failed. Dropping a
   // packet here should be treated as any other packet drop so we should be
   // ready for a retransmission.
   packet_history_.SetSent(rtp_header.sequenceNumber);
@@ skipping 568 matching lines @@
     default:
       RTC_NOTREACHED();
   }
 
   // Update absolute send time field (convert ms to 24-bit unsigned with 18 bit
   // fractional part).
   ByteWriter<uint32_t, 3>::WriteBigEndian(rtp_packet + offset + 1,
                                           ConvertMsTo24Bits(now_ms));
 }
 
-bool RTPSender::UpdateTransportSequenceNumber(
-    uint16_t sequence_number,
-    uint8_t* rtp_packet,
-    size_t rtp_packet_length,
-    const RTPHeader& rtp_header) const {
+bool RTPSender::UpdateTransportSequenceNumber(uint8_t* rtp_packet,
+                                              size_t rtp_packet_length,
+                                              const RTPHeader& rtp_header,
+                                              int* sequence_number) const {
+  RTC_DCHECK(sequence_number);
   size_t offset;
   rtc::CritScope lock(&send_critsect_);
 
   switch (VerifyExtension(kRtpExtensionTransportSequenceNumber, rtp_packet,
                           rtp_packet_length, rtp_header,
                           kTransportSequenceNumberLength, &offset)) {
     case ExtensionStatus::kNotRegistered:
       return false;
     case ExtensionStatus::kError:
       LOG(LS_WARNING) << "Failed to update transport sequence number";
       return false;
     case ExtensionStatus::kOk:
       break;
     default:
       RTC_NOTREACHED();
   }
 
-  BuildTransportSequenceNumberExtension(rtp_packet + offset, sequence_number);
+  if (!AllocateTransportSequenceNumber(sequence_number))
+    return false;
+
+  BuildTransportSequenceNumberExtension(rtp_packet + offset, *sequence_number);
   return true;
 }
 
 bool RTPSender::AllocateTransportSequenceNumber(int* packet_id) const {
   if (!transport_sequence_number_allocator_)
     return false;
 
   *packet_id = transport_sequence_number_allocator_->AllocateSequenceNumber();
   return true;
 }
@@ skipping 261 matching lines @@
   rtc::CritScope lock(&send_critsect_);
 
   RtpState state;
   state.sequence_number = sequence_number_rtx_;
   state.start_timestamp = start_timestamp_;
 
   return state;
 }
 
 }  // namespace webrtc