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

webrtc/modules/rtp_rtcp/source/rtp_sender.h

 /*
  *  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 148 matching lines @@
   int32_t SetAbsoluteSendTime(uint32_t absolute_send_time);
   void SetVideoRotation(VideoRotation rotation);
   int32_t SetTransportSequenceNumber(uint16_t sequence_number);
 
   int32_t RegisterRtpHeaderExtension(RTPExtensionType type, uint8_t id);
   bool IsRtpHeaderExtensionRegistered(RTPExtensionType type) override;
   int32_t DeregisterRtpHeaderExtension(RTPExtensionType type);
 
   size_t RtpHeaderExtensionLength() const;
 
-  uint16_t BuildRTPHeaderExtension(uint8_t* data_buffer, bool marker_bit) const;
+  uint16_t BuildRTPHeaderExtension(uint8_t* data_buffer, bool marker_bit) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
 
-  uint8_t BuildTransmissionTimeOffsetExtension(uint8_t *data_buffer) const;
-  uint8_t BuildAudioLevelExtension(uint8_t* data_buffer) const;
-  uint8_t BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const;
-  uint8_t BuildVideoRotationExtension(uint8_t* data_buffer) const;
+  uint8_t BuildTransmissionTimeOffsetExtension(uint8_t* data_buffer) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
+  uint8_t BuildAudioLevelExtension(uint8_t* data_buffer) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
+  uint8_t BuildAbsoluteSendTimeExtension(uint8_t* data_buffer) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
+  uint8_t BuildVideoRotationExtension(uint8_t* data_buffer) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
   uint8_t BuildTransportSequenceNumberExtension(uint8_t* data_buffer,
-                                                uint16_t sequence_number) const;
+                                                uint16_t sequence_number) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
   uint8_t BuildPlayoutDelayExtension(uint8_t* data_buffer,
                                      uint16_t min_playout_delay_ms,
-                                     uint16_t max_playout_delay_ms) const;
+                                     uint16_t max_playout_delay_ms) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
 
   // Verifies that the specified extension is registered, and that it is
   // present in rtp packet. If extension is not registered kNotRegistered is
   // returned. If extension cannot be found in the rtp header, or if it is
   // malformed, kError is returned. Otherwise *extension_offset is set to the
   // offset of the extension from the beginning of the rtp packet and kOk is
   // returned.
   enum class ExtensionStatus {
     kNotRegistered,
     kOk,
@@ skipping 138 matching lines @@
   // Send-side delay is the difference between transmission time and capture
   // time.
   typedef std::map<int64_t, int> SendDelayMap;
 
   size_t CreateRtpHeader(uint8_t* header,
                          int8_t payload_type,
                          uint32_t ssrc,
                          bool marker_bit,
                          uint32_t timestamp,
                          uint16_t sequence_number,
-                         const std::vector<uint32_t>& csrcs) const;
+                         const std::vector<uint32_t>& csrcs) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
 
   bool PrepareAndSendPacket(uint8_t* buffer,
                             size_t length,
                             int64_t capture_time_ms,
                             bool send_over_rtx,
                             bool is_retransmit,
                             int probe_cluster_id);
 
   // Return the number of bytes sent.  Note that both of these functions may
   // return a larger value that their argument.
@@ skipping 14 matching lines @@
   void UpdateOnSendPacket(int packet_id,
                           int64_t capture_time_ms,
                           uint32_t ssrc);
 
   // Find the byte position of the RTP extension as indicated by |type| in
   // |rtp_packet|. Return false if such extension doesn't exist.
   bool FindHeaderExtensionPosition(RTPExtensionType type,
                                    const uint8_t* rtp_packet,
                                    size_t rtp_packet_length,
                                    const RTPHeader& rtp_header,
-                                   size_t* position) const;
+                                   size_t* position) const
+      EXCLUSIVE_LOCKS_REQUIRED(send_critsect_);
 
   void UpdateTransmissionTimeOffset(uint8_t* rtp_packet,
                                     size_t rtp_packet_length,
                                     const RTPHeader& rtp_header,
                                     int64_t time_diff_ms) const;
   void UpdateAbsoluteSendTime(uint8_t* rtp_packet,
                               size_t rtp_packet_length,
                               const RTPHeader& rtp_header,
                               int64_t now_ms) const;
 
-  bool UpdateTransportSequenceNumber(uint16_t sequence_number,
-                                     uint8_t* rtp_packet,
+  bool UpdateTransportSequenceNumber(uint8_t* rtp_packet,
                                      size_t rtp_packet_length,
-                                     const RTPHeader& rtp_header) const;
+                                     const RTPHeader& rtp_header,
+                                     int* sequence_number) const;
 
   void UpdatePlayoutDelayLimits(uint8_t* rtp_packet,
                                 size_t rtp_packet_length,
                                 const RTPHeader& rtp_header,
                                 uint16_t min_playout_delay,
                                 uint16_t max_playout_delay) const;
 
   bool AllocateTransportSequenceNumber(int* packet_id) const;
 
   void UpdateRtpStats(const uint8_t* buffer,
@@ skipping 18 matching lines @@
   rtc::CriticalSection send_critsect_;
 
   Transport *transport_;
   bool sending_media_ GUARDED_BY(send_critsect_);
 
   size_t max_payload_length_;
 
   int8_t payload_type_ GUARDED_BY(send_critsect_);
   std::map<int8_t, RtpUtility::Payload*> payload_type_map_;
 
-  RtpHeaderExtensionMap rtp_header_extension_map_;
+  RtpHeaderExtensionMap rtp_header_extension_map_ GUARDED_BY(send_critsect_);
   int32_t transmission_time_offset_;
   uint32_t absolute_send_time_;
   VideoRotation rotation_;
   bool video_rotation_active_;
   uint16_t transport_sequence_number_;
 
   // Tracks the current request for playout delay limits from application
   // and decides whether the current RTP frame should include the playout
   // delay extension on header.
   PlayoutDelayOracle playout_delay_oracle_;
@@ skipping 38 matching lines @@
   std::map<int8_t, int8_t> rtx_payload_type_map_ GUARDED_BY(send_critsect_);
 
   RateLimiter* const retransmission_rate_limiter_;
 
   RTC_DISALLOW_IMPLICIT_CONSTRUCTORS(RTPSender);
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTP_SENDER_H_