Remove contention between RTCP packets and encoding.

webrtc/video_engine/vie_encoder.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 104 matching lines @@
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      this,
                                      qm_callback_.get())),
       send_payload_router_(NULL),
       data_cs_(CriticalSectionWrapper::CreateCriticalSection()),
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       pacer_(pacer),
       bitrate_allocator_(bitrate_allocator),
       time_of_last_frame_activity_ms_(0),
-      simulcast_enabled_(false),
+      encoder_config_(),
       min_transmit_bitrate_kbps_(0),
       last_observed_bitrate_bps_(0),
       target_delay_ms_(0),
       network_is_transmitting_(true),
       encoder_paused_(false),
       encoder_paused_and_dropped_frame_(false),
-      fec_enabled_(false),
-      nack_enabled_(false),
       module_process_thread_(module_process_thread),
       has_received_sli_(false),
       picture_id_sli_(0),
       has_received_rpsi_(false),
       picture_id_rpsi_(0),
       video_suspended_(false) {
   bitrate_observer_.reset(new ViEBitrateObserver(this));
 }
 
 bool ViEEncoder::Init() {
@@ skipping 80 matching lines @@
 }
 
 int32_t ViEEncoder::SetEncoder(const webrtc::VideoCodec& video_codec) {
   RTC_DCHECK(send_payload_router_ != NULL);
   // Setting target width and height for VPM.
   if (vpm_->SetTargetResolution(video_codec.width, video_codec.height,
                                 video_codec.maxFramerate) != VPM_OK) {
     return -1;
   }
 
+  // Cache codec before calling AddBitrateObserver (which calls OnNetworkChanged
+  // that makes use of the number of simulcast streams configured).
   {
     CriticalSectionScoped cs(data_cs_.get());
-    simulcast_enabled_ = video_codec.numberOfSimulcastStreams > 1;
+    encoder_config_ = video_codec;
   }
 
   // Add a bitrate observer to the allocator and update the start, max and
   // min bitrates of the bitrate controller as needed.
   int allocated_bitrate_bps = bitrate_allocator_->AddBitrateObserver(
       bitrate_observer_.get(), video_codec.minBitrate * 1000,
       video_codec.maxBitrate * 1000);
 
   webrtc::VideoCodec modified_video_codec = video_codec;
   modified_video_codec.startBitrate = allocated_bitrate_bps / 1000;
 
   size_t max_data_payload_length = send_payload_router_->MaxPayloadLength();
   if (vcm_->RegisterSendCodec(&modified_video_codec, number_of_cores_,
                               static_cast<uint32_t>(max_data_payload_length)) !=
       VCM_OK) {
     return -1;
   }
   return 0;
 }
 
-int32_t ViEEncoder::GetEncoder(VideoCodec* video_codec) {
-  *video_codec = vcm_->GetSendCodec();
-  return 0;
-}
-
 int32_t ViEEncoder::ScaleInputImage(bool enable) {
   VideoFrameResampling resampling_mode = kFastRescaling;
   // TODO(mflodman) What?
   if (enable) {
     // kInterpolation is currently not supported.
     LOG_F(LS_ERROR) << "Not supported.";
     return -1;
   }
   vpm_->SetInputFrameResampleMode(resampling_mode);
 
   return 0;
 }
 
 int ViEEncoder::GetPaddingNeededBps() const {
   int64_t time_of_last_frame_activity_ms;
   int min_transmit_bitrate_bps;
   int bitrate_bps;
+  VideoCodec send_codec;
   {
     CriticalSectionScoped cs(data_cs_.get());
-    bool send_padding = simulcast_enabled_ || video_suspended_ ||
-                        min_transmit_bitrate_kbps_ > 0;
+    bool send_padding = encoder_config_.numberOfSimulcastStreams > 1 ||
+                        video_suspended_ || min_transmit_bitrate_kbps_ > 0;
     if (!send_padding)
       return 0;
     time_of_last_frame_activity_ms = time_of_last_frame_activity_ms_;
     min_transmit_bitrate_bps = 1000 * min_transmit_bitrate_kbps_;
     bitrate_bps = last_observed_bitrate_bps_;
+    send_codec = encoder_config_;
   }
 
-  VideoCodec send_codec;
-  if (vcm_->SendCodec(&send_codec) != 0)
-    return 0;
-
   bool video_is_suspended = vcm_->VideoSuspended();
 
   // Find the max amount of padding we can allow ourselves to send at this
   // point, based on which streams are currently active and what our current
   // available bandwidth is.
   int pad_up_to_bitrate_bps = 0;
   if (send_codec.numberOfSimulcastStreams == 0) {
     pad_up_to_bitrate_bps = send_codec.minBitrate * 1000;
   } else {
     SimulcastStream* stream_configs = send_codec.simulcastStream;
@@ skipping 66 matching lines @@
   encoder_paused_and_dropped_frame_ = false;
 }
 
 void ViEEncoder::DeliverFrame(VideoFrame video_frame) {
   RTC_DCHECK(send_payload_router_ != NULL);
   if (!send_payload_router_->active()) {
     // We've paused or we have no channels attached, don't waste resources on
     // encoding.
     return;
   }
+  VideoCodecType codec_type;
   {
     CriticalSectionScoped cs(data_cs_.get());
     time_of_last_frame_activity_ms_ = TickTime::MillisecondTimestamp();
     if (EncoderPaused()) {
       TraceFrameDropStart();
       return;
     }
     TraceFrameDropEnd();
+    codec_type = encoder_config_.codecType;
   }
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
   VideoFrame* decimated_frame = NULL;
   // TODO(wuchengli): support texture frames.
   if (video_frame.native_handle() == NULL) {
     // Pass frame via preprocessor.
     const int ret = vpm_->PreprocessFrame(video_frame, &decimated_frame);
     if (ret == 1) {
@@ skipping 16 matching lines @@
     }
     pre_encode_callback_->FrameCallback(decimated_frame);
   }
 
   // If the frame was not resampled, scaled, or touched by FrameCallback => use
   // original. The frame is const from here.
   const VideoFrame* output_frame =
       (decimated_frame != NULL) ? decimated_frame : &video_frame;
 
 #ifdef VIDEOCODEC_VP8
-  if (vcm_->SendCodec() == webrtc::kVideoCodecVP8) {
+  if (codec_type == webrtc::kVideoCodecVP8) {
     webrtc::CodecSpecificInfo codec_specific_info;
     codec_specific_info.codecType = webrtc::kVideoCodecVP8;
     {
       CriticalSectionScoped cs(data_cs_.get());
       codec_specific_info.codecSpecific.VP8.hasReceivedRPSI =
           has_received_rpsi_;
       codec_specific_info.codecSpecific.VP8.hasReceivedSLI =
           has_received_sli_;
       codec_specific_info.codecSpecific.VP8.pictureIdRPSI =
           picture_id_rpsi_;
@@ skipping 19 matching lines @@
   CriticalSectionScoped cs(data_cs_.get());
   return last_observed_bitrate_bps_;
 }
 
 int ViEEncoder::CodecTargetBitrate(uint32_t* bitrate) const {
   if (vcm_->Bitrate(bitrate) != 0)
     return -1;
   return 0;
 }
 
-int32_t ViEEncoder::UpdateProtectionMethod(bool nack, bool fec) {
-  RTC_DCHECK(send_payload_router_ != NULL);
-
-  if (fec_enabled_ == fec && nack_enabled_ == nack) {
-    // No change needed, we're already in correct state.
-    return 0;
-  }
-  fec_enabled_ = fec;
-  nack_enabled_ = nack;
-
+void ViEEncoder::SetProtectionMethod(bool nack, bool fec) {
   // Set Video Protection for VCM.
   VCMVideoProtection protection_mode;
-  if (fec_enabled_) {
+  if (fec) {
     protection_mode =
-        nack_enabled_ ? webrtc::kProtectionNackFEC : kProtectionFEC;
+        nack ? webrtc::kProtectionNackFEC : kProtectionFEC;
   } else {
-    protection_mode = nack_enabled_ ? kProtectionNack : kProtectionNone;
+    protection_mode = nack ? kProtectionNack : kProtectionNone;
   }
   vcm_->SetVideoProtection(protection_mode, true);
-
-  if (fec_enabled_ || nack_enabled_) {
-    // The send codec must be registered to set correct MTU.

[stefan-webrtc, 2015/11/10 15:15:26]

So now the user of this class needs to make sure it calls SetSendCodec after
calling SetProtectionMethod? 

[pbos-webrtc, 2015/11/10 15:18:52]

Yep, commented.

-    webrtc::VideoCodec codec;
-    if (vcm_->SendCodec(&codec) == 0) {
-      uint32_t current_bitrate_bps = 0;
-      if (vcm_->Bitrate(&current_bitrate_bps) != 0) {
-        LOG_F(LS_WARNING) <<
-            "Failed to get the current encoder target bitrate.";
-      }
-      // Convert to start bitrate in kbps.
-      codec.startBitrate = (current_bitrate_bps + 500) / 1000;
-      size_t max_payload_length = send_payload_router_->MaxPayloadLength();
-      if (vcm_->RegisterSendCodec(&codec, number_of_cores_,
-                                  static_cast<uint32_t>(max_payload_length)) !=
-          0) {
-        return -1;
-      }
-    }
-  }
-  return 0;
 }
 
 void ViEEncoder::SetSenderBufferingMode(int target_delay_ms) {
   {
     CriticalSectionScoped cs(data_cs_.get());
     target_delay_ms_ = target_delay_ms;
   }
   if (target_delay_ms > 0) {
     // Disable external frame-droppers.
     vcm_->EnableFrameDropper(false);
@@ skipping 98 matching lines @@
   std::map<unsigned int, int64_t>::iterator time_it =
       time_last_intra_request_ms_.find(old_ssrc);
   int64_t last_intra_request_ms = 0;
   if (time_it != time_last_intra_request_ms_.end()) {
     last_intra_request_ms = time_it->second;
     time_last_intra_request_ms_.erase(time_it);
   }
   time_last_intra_request_ms_[new_ssrc] = last_intra_request_ms;
 }
 
-bool ViEEncoder::SetSsrcs(const std::vector<uint32_t>& ssrcs) {
-  VideoCodec codec;
-  if (vcm_->SendCodec(&codec) != 0)
-    return false;
-
-  if (codec.numberOfSimulcastStreams > 0 &&
-      ssrcs.size() != codec.numberOfSimulcastStreams) {
-    return false;
-  }
-
+void ViEEncoder::SetSsrcs(const std::vector<uint32_t>& ssrcs) {
   CriticalSectionScoped cs(data_cs_.get());
   ssrc_streams_.clear();
   time_last_intra_request_ms_.clear();
   int idx = 0;
   for (uint32_t ssrc : ssrcs) {
     ssrc_streams_[ssrc] = idx++;
   }
-  return true;
 }
 
 void ViEEncoder::SetMinTransmitBitrate(int min_transmit_bitrate_kbps) {
   assert(min_transmit_bitrate_kbps >= 0);
   CriticalSectionScoped crit(data_cs_.get());
   min_transmit_bitrate_kbps_ = min_transmit_bitrate_kbps;
 }
 
 // Called from ViEBitrateObserver.
 void ViEEncoder::OnNetworkChanged(uint32_t bitrate_bps,
                                   uint8_t fraction_lost,
                                   int64_t round_trip_time_ms) {
   LOG(LS_VERBOSE) << "OnNetworkChanged, bitrate" << bitrate_bps
                   << " packet loss " << static_cast<int>(fraction_lost)
                   << " rtt " << round_trip_time_ms;
   RTC_DCHECK(send_payload_router_ != NULL);
   vcm_->SetChannelParameters(bitrate_bps, fraction_lost, round_trip_time_ms);
   bool video_is_suspended = vcm_->VideoSuspended();
+  bool video_suspension_changed;
+  VideoCodec send_codec;
+  uint32_t first_ssrc;
+  {
+    CriticalSectionScoped cs(data_cs_.get());
+    last_observed_bitrate_bps_ = bitrate_bps;
+    video_suspension_changed = video_suspended_ != video_is_suspended;
+    video_suspended_ = video_is_suspended;
+    send_codec = encoder_config_;
+    first_ssrc = ssrc_streams_.begin()->first;
+  }
 
-  VideoCodec send_codec;
-  if (vcm_->SendCodec(&send_codec) != 0) {
-    return;
-  }
   SimulcastStream* stream_configs = send_codec.simulcastStream;
   // Allocate the bandwidth between the streams.
   std::vector<uint32_t> stream_bitrates = AllocateStreamBitrates(
       bitrate_bps, stream_configs, send_codec.numberOfSimulcastStreams);
   send_payload_router_->SetTargetSendBitrates(stream_bitrates);
 
-  {
-    CriticalSectionScoped cs(data_cs_.get());
-    last_observed_bitrate_bps_ = bitrate_bps;
-    if (video_suspended_ == video_is_suspended)
-      return;
-    video_suspended_ = video_is_suspended;
-
-    LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
-                 << " for ssrc " << ssrc_streams_.begin()->first;
-  }
+  if (!video_suspension_changed)
+    return;
   // Video suspend-state changed, inform codec observer.
+  LOG(LS_INFO) << "Video suspend state changed " << video_is_suspended
+               << " for ssrc " << first_ssrc;
   if (stats_proxy_)
     stats_proxy_->OnSuspendChange(video_is_suspended);
 }
 
 void ViEEncoder::SuspendBelowMinBitrate() {
   vcm_->SuspendBelowMinBitrate();
   bitrate_allocator_->EnforceMinBitrate(false);
 }
 
 void ViEEncoder::RegisterPostEncodeImageCallback(
@@ skipping 13 matching lines @@
     const uint32_t width,
     const uint32_t height) {
   return vpm_->SetTargetResolution(width, height, frame_rate);
 }
 
 void QMVideoSettingsCallback::SetTargetFramerate(int frame_rate) {
   vpm_->SetTargetFramerate(frame_rate);
 }
 
 }  // namespace webrtc