Reduce taking locks in RTPSenderVideo::SendVideo

webrtc/modules/rtp_rtcp/source/rtp_sender_video.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 40 matching lines @@
       clock_(clock),
       video_type_(kRtpVideoGeneric),
       retransmission_settings_(kRetransmitBaseLayer),
       last_rotation_(kVideoRotation_0),
       red_payload_type_(-1),
       ulpfec_payload_type_(-1),
       flexfec_sender_(flexfec_sender),
       delta_fec_params_{0, 1, kFecMaskRandom},
       key_fec_params_{0, 1, kFecMaskRandom},
       fec_bitrate_(1000, RateStatistics::kBpsScale),
-      video_bitrate_(1000, RateStatistics::kBpsScale) { }

[brandtr, 2016/11/11 07:50:27]

I noticed this in the other CL, nice to fix :)

+      video_bitrate_(1000, RateStatistics::kBpsScale) {}
 
 RTPSenderVideo::~RTPSenderVideo() {}
 
 void RTPSenderVideo::SetVideoCodecType(RtpVideoCodecTypes video_type) {
   video_type_ = video_type;
 }
 
 RtpVideoCodecTypes RTPSenderVideo::VideoCodecType() const {
   return video_type_;
 }
@@ skipping 164 matching lines @@
   key_fec_params_ = FecProtectionParams{0, 1, kFecMaskRandom};
 }
 
 void RTPSenderVideo::GetUlpfecConfig(int* red_payload_type,
                                      int* ulpfec_payload_type) const {
   rtc::CritScope cs(&crit_);
   *red_payload_type = red_payload_type_;
   *ulpfec_payload_type = ulpfec_payload_type_;
 }
 
-size_t RTPSenderVideo::FecPacketOverhead() const {
+size_t RTPSenderVideo::CalculateFecPacketOverhead() const {
   if (flexfec_enabled())
     return flexfec_sender_->MaxPacketOverhead();
 
-  rtc::CritScope cs(&crit_);
   size_t overhead = 0;
   if (red_enabled()) {
     // The RED overhead is due to a small header.
     overhead += kRedForFecHeaderLength;
   }
   if (ulpfec_enabled()) {
     // For ULPFEC, the overhead is the FEC headers plus RED for FEC header
     // (see above) plus anything in RTP header beyond the 12 bytes base header
     // (CSRC list, extensions...)
     // This reason for the header extensions to be included here is that
@@ skipping 22 matching lines @@
                                const RTPFragmentationHeader* fragmentation,
                                const RTPVideoHeader* video_header) {
   if (payload_size == 0)
     return false;
 
   // Create header that will be reused in all packets.
   std::unique_ptr<RtpPacketToSend> rtp_header = rtp_sender_->AllocatePacket();
   rtp_header->SetPayloadType(payload_type);
   rtp_header->SetTimestamp(rtp_timestamp);
   rtp_header->set_capture_time_ms(capture_time_ms);
-  // According to
-  // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/
-  // ts_126114v120700p.pdf Section 7.4.5:
-  // The MTSI client shall add the payload bytes as defined in this clause
-  // onto the last RTP packet in each group of packets which make up a key
-  // frame (I-frame or IDR frame in H.264 (AVC), or an IRAP picture in H.265
-  // (HEVC)). The MTSI client may also add the payload bytes onto the last RTP
-  // packet in each group of packets which make up another type of frame
-  // (e.g. a P-Frame) only if the current value is different from the previous
-  // value sent.
-  if (video_header) {
-    // Set rotation when key frame or when changed (to follow standard).
-    // Or when different from 0 (to follow current receiver implementation).
-    // TODO(kthelgason): Merge this crit scope with the one below.
+
+  size_t fec_packet_overhead;
+  bool red_enabled;
+  int32_t retransmission_settings;
+  {
     rtc::CritScope cs(&crit_);
-    VideoRotation current_rotation = video_header->rotation;
-    if (frame_type == kVideoFrameKey || current_rotation != last_rotation_ ||
-        current_rotation != kVideoRotation_0)
-      rtp_header->SetExtension<VideoOrientation>(current_rotation);
-    last_rotation_ = current_rotation;
+    // According to
+    // http://www.etsi.org/deliver/etsi_ts/126100_126199/126114/12.07.00_60/
+    // ts_126114v120700p.pdf Section 7.4.5:
+    // The MTSI client shall add the payload bytes as defined in this clause
+    // onto the last RTP packet in each group of packets which make up a key
+    // frame (I-frame or IDR frame in H.264 (AVC), or an IRAP picture in H.265
+    // (HEVC)). The MTSI client may also add the payload bytes onto the last RTP
+    // packet in each group of packets which make up another type of frame
+    // (e.g. a P-Frame) only if the current value is different from the previous
+    // value sent.
+    if (video_header) {
+      // Set rotation when key frame or when changed (to follow standard).
+      // Or when different from 0 (to follow current receiver implementation).
+      VideoRotation current_rotation = video_header->rotation;
+      if (frame_type == kVideoFrameKey || current_rotation != last_rotation_ ||
+          current_rotation != kVideoRotation_0)
+        rtp_header->SetExtension<VideoOrientation>(current_rotation);
+      last_rotation_ = current_rotation;
+    }
+
+    // FEC settings.
+    const FecProtectionParams& fec_params =
+        frame_type == kVideoFrameKey ? key_fec_params_ : delta_fec_params_;
+    if (flexfec_enabled())
+      flexfec_sender_->SetFecParameters(fec_params);
+    if (ulpfec_enabled())
+      ulpfec_generator_.SetFecParameters(fec_params);
+
+    fec_packet_overhead = CalculateFecPacketOverhead();
+    red_enabled = this->red_enabled();
+    retransmission_settings = retransmission_settings_;
   }
 
   size_t packet_capacity = rtp_sender_->MaxPayloadLength() -
-                           FecPacketOverhead() -
+                           fec_packet_overhead -
                            (rtp_sender_->RtxStatus() ? kRtxHeaderSize : 0);
   RTC_DCHECK_LE(packet_capacity, rtp_header->capacity());
   RTC_DCHECK_GT(packet_capacity, rtp_header->headers_size());
   size_t max_data_payload_length = packet_capacity - rtp_header->headers_size();
 
   std::unique_ptr<RtpPacketizer> packetizer(RtpPacketizer::Create(
       video_type, max_data_payload_length,
       video_header ? &(video_header->codecHeader) : nullptr, frame_type));
-
-  StorageType storage;
-  bool red_enabled;
-  bool first_frame = first_frame_sent_();
-  {
-    rtc::CritScope cs(&crit_);
-
-    // Media packet storage.
-    storage = packetizer->GetStorageType(retransmission_settings_);
-
-    // FEC settings.
-    const FecProtectionParams& fec_params =
-        frame_type == kVideoFrameKey ? key_fec_params_ : delta_fec_params_;
-    if (flexfec_enabled())
-      flexfec_sender_->SetFecParameters(fec_params);
-    red_enabled = this->red_enabled();
-    if (ulpfec_enabled())
-      ulpfec_generator_.SetFecParameters(fec_params);
-  }
+  // Media packet storage.
+  StorageType storage = packetizer->GetStorageType(retransmission_settings);
 
   // TODO(changbin): we currently don't support to configure the codec to
   // output multiple partitions for VP8. Should remove below check after the
   // issue is fixed.
   const RTPFragmentationHeader* frag =
-      (video_type == kRtpVideoVp8) ? NULL : fragmentation;
-
+      (video_type == kRtpVideoVp8) ? nullptr : fragmentation;
   packetizer->SetPayloadData(payload_data, payload_size, frag);
 
+  bool first_frame = first_frame_sent_();
   bool first = true;
   bool last = false;
   while (!last) {
     std::unique_ptr<RtpPacketToSend> packet(new RtpPacketToSend(*rtp_header));
     uint8_t* payload = packet->AllocatePayload(max_data_payload_length);
     RTC_DCHECK(payload);
 
     size_t payload_bytes_in_packet = 0;
     if (!packetizer->NextPacket(payload, &payload_bytes_in_packet, &last))
       return false;
@@ skipping 48 matching lines @@
   rtc::CritScope cs(&crit_);
   return retransmission_settings_;
 }
 
 void RTPSenderVideo::SetSelectiveRetransmissions(uint8_t settings) {
   rtc::CritScope cs(&crit_);
   retransmission_settings_ = settings;
 }
 
 }  // namespace webrtc