Remove ViEncoder::Pause / Start

webrtc/video/video_send_stream.cc

 /*
  *  Copyright (c) 2013 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 377 matching lines @@
       config_(config),
       suspended_ssrcs_(suspended_ssrcs),
       module_process_thread_(module_process_thread),
       call_stats_(call_stats),
       congestion_controller_(congestion_controller),
       bitrate_allocator_(bitrate_allocator),
       remb_(remb),
       encoder_thread_(EncoderThreadFunction, this, "EncoderThread"),
       encoder_wakeup_event_(false, false),
       stop_encoder_thread_(0),
-      send_stream_registered_as_observer_(false),
+      state_(State::kStopped),
       overuse_detector_(
           Clock::GetRealTimeClock(),
           GetCpuOveruseOptions(config.encoder_settings.full_overuse_time),
           this,
           config.post_encode_callback,
           &stats_proxy_),
       vie_encoder_(num_cpu_cores,
                    module_process_thread_,
                    &stats_proxy_,
                    &overuse_detector_,
@@ skipping 23 matching lines @@
              &stats_proxy_,
              &overuse_detector_) {
   LOG(LS_INFO) << "VideoSendStream: " << config_.ToString();
 
   RTC_DCHECK(!config_.rtp.ssrcs.empty());
   RTC_DCHECK(module_process_thread_);
   RTC_DCHECK(call_stats_);
   RTC_DCHECK(congestion_controller_);
   RTC_DCHECK(remb_);
 
-
   // RTP/RTCP initialization.
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     module_process_thread_->RegisterModule(rtp_rtcp);
     congestion_controller_->packet_router()->AddRtpModule(rtp_rtcp);
   }
 
   for (size_t i = 0; i < config_.rtp.extensions.size(); ++i) {
     const std::string& extension = config_.rtp.extensions[i].uri;
     int id = config_.rtp.extensions[i].id;
     // One-byte-extension local identifiers are in the range 1-14 inclusive.
@@ skipping 28 matching lines @@
         config_.encoder_settings.payload_name.c_str());
   }
 
   RTC_DCHECK(config.encoder_settings.encoder);
   RTC_DCHECK_GE(config.encoder_settings.payload_type, 0);
   RTC_DCHECK_LE(config.encoder_settings.payload_type, 127);
   ReconfigureVideoEncoder(encoder_config);
 
   module_process_thread_->RegisterModule(&overuse_detector_);
 
+  encoder_thread_checker_.DetachFromThread();
   encoder_thread_.Start();
   encoder_thread_.SetPriority(rtc::kHighPriority);
 }
 
 VideoSendStream::~VideoSendStream() {
   LOG(LS_INFO) << "~VideoSendStream: " << config_.ToString();
 
   Stop();
 
   // Stop the encoder thread permanently.
@@ skipping 21 matching lines @@
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     rtp_rtcp->IncomingRtcpPacket(packet, length);
   return true;
 }
 
 void VideoSendStream::Start() {
   if (payload_router_.active())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Start");
   payload_router_.set_active(true);
-  // Was not already started, trigger a keyframe.
-  vie_encoder_.SendKeyFrame();
-  vie_encoder_.Start();
+  {
+    rtc::CritScope lock(&encoder_settings_crit_);
+    pending_state_change_ = rtc::Optional<State>(State::kStarted);
+  }
+  encoder_wakeup_event_.Set();
 }
 
 void VideoSendStream::Stop() {
   if (!payload_router_.active())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
-  vie_encoder_.Pause();
   payload_router_.set_active(false);
+  {
+    rtc::CritScope lock(&encoder_settings_crit_);
+    pending_state_change_ = rtc::Optional<State>(State::kStopped);
+  }
+  encoder_wakeup_event_.Set();
 }
 
 VideoCaptureInput* VideoSendStream::Input() {
   return &input_;
 }
 
 bool VideoSendStream::EncoderThreadFunction(void* obj) {
   static_cast<VideoSendStream*>(obj)->EncoderProcess();
   // We're done, return false to abort.
   return false;
 }
 
 void VideoSendStream::EncoderProcess() {
   RTC_CHECK_EQ(0, vie_encoder_.RegisterExternalEncoder(
                       config_.encoder_settings.encoder,
                       config_.encoder_settings.payload_type,
                       config_.encoder_settings.internal_source));
-
+  RTC_DCHECK_RUN_ON(&encoder_thread_checker_);
   while (true) {
     // Wake up every kEncodeCheckForActivityPeriodMs to check if the encoder is
     // active. If not, deregister as BitrateAllocatorObserver.
     const int kEncodeCheckForActivityPeriodMs = 1000;
     encoder_wakeup_event_.Wait(kEncodeCheckForActivityPeriodMs);
     if (rtc::AtomicOps::AcquireLoad(&stop_encoder_thread_))
       break;
     bool change_settings = false;
+    rtc::Optional<State> pending_state_change;
     {
       rtc::CritScope lock(&encoder_settings_crit_);
       if (pending_encoder_settings_) {
         std::swap(current_encoder_settings_, pending_encoder_settings_);
         pending_encoder_settings_.reset();
         change_settings = true;
+      } else if (pending_state_change_) {
+        swap(pending_state_change, pending_state_change_);
       }
     }
     if (change_settings) {
-      current_encoder_settings_->video_codec.startBitrate =
-          bitrate_allocator_->AddObserver(
-              this, current_encoder_settings_->video_codec.minBitrate * 1000,
-              current_encoder_settings_->video_codec.maxBitrate * 1000,
-              CalulcateMaxPadBitrateBps(current_encoder_settings_->config,
-                                        config_.suspend_below_min_bitrate),
-              !config_.suspend_below_min_bitrate) /
-          1000;
-      send_stream_registered_as_observer_ = true;
-
+      current_encoder_settings_->video_codec.startBitrate = std::max(
+          bitrate_allocator_->GetStartBitrate(this) / 1000,
+          static_cast<int>(current_encoder_settings_->video_codec.minBitrate));
       payload_router_.SetSendStreams(current_encoder_settings_->config.streams);
       vie_encoder_.SetEncoder(current_encoder_settings_->video_codec,
                               payload_router_.MaxPayloadLength());
 
       // Clear stats for disabled layers.
       for (size_t i = current_encoder_settings_->config.streams.size();
            i < config_.rtp.ssrcs.size(); ++i) {
         stats_proxy_.OnInactiveSsrc(config_.rtp.ssrcs[i]);
       }
 
       size_t number_of_temporal_layers =
           current_encoder_settings_->config.streams.back()
               .temporal_layer_thresholds_bps.size() +
           1;
       protection_bitrate_calculator_.SetEncodingData(
           current_encoder_settings_->video_codec.startBitrate * 1000,
           current_encoder_settings_->video_codec.width,
           current_encoder_settings_->video_codec.height,
           current_encoder_settings_->video_codec.maxFramerate,
           number_of_temporal_layers, payload_router_.MaxPayloadLength());
 
       // We might've gotten new settings while configuring the encoder settings,
       // restart from the top to see if that's the case before trying to encode
       // a frame (which might correspond to the last frame size).
       encoder_wakeup_event_.Set();
       continue;
     }
 
-    VideoFrame frame;
-    if (input_.GetVideoFrame(&frame)) {
-      // TODO(perkj): |pre_encode_callback| is only used by tests. Tests should
-      // register as a sink to the VideoSource instead.
-      if (config_.pre_encode_callback) {
-        config_.pre_encode_callback->OnFrame(frame);
+    if (pending_state_change) {
+      if (*pending_state_change == State::kStarted &&
+          state_ == State::kStopped) {
+        bitrate_allocator_->AddObserver(
+            this, current_encoder_settings_->video_codec.minBitrate * 1000,
+            current_encoder_settings_->video_codec.maxBitrate * 1000,
+            CalulcateMaxPadBitrateBps(current_encoder_settings_->config,
+                                      config_.suspend_below_min_bitrate),
+            !config_.suspend_below_min_bitrate);
+        vie_encoder_.SendKeyFrame();
+        state_ = State::kStarted;
+        LOG_F(LS_INFO) << "Encoder started.";
+      } else if (*pending_state_change == State::kStopped) {
+        bitrate_allocator_->RemoveObserver(this);
+        vie_encoder_.OnBitrateUpdated(0, 0, 0);
+        state_ = State::kStopped;
+        LOG_F(LS_INFO) << "Encoder stopped.";
       }
-      vie_encoder_.EncodeVideoFrame(frame);
+      encoder_wakeup_event_.Set();
+      continue;
     }
 
     // Check if the encoder has produced anything the last kEncoderTimeOutMs.
     // If not, deregister as BitrateAllocatorObserver.
-    if (send_stream_registered_as_observer_ &&
+    if (state_ == State::kStarted &&
         vie_encoder_.time_of_last_frame_activity_ms() <
             rtc::TimeMillis() - kEncoderTimeOutMs) {
       // The encoder has timed out.
       LOG_F(LS_INFO) << "Encoder timed out.";
       bitrate_allocator_->RemoveObserver(this);
-      send_stream_registered_as_observer_ = false;
+      state_ = State::kEncoderTimedOut;
     }
-    if (!send_stream_registered_as_observer_ &&
+    if (state_ == State::kEncoderTimedOut &&
         vie_encoder_.time_of_last_frame_activity_ms() >
             rtc::TimeMillis() - kEncoderTimeOutMs) {
       LOG_F(LS_INFO) << "Encoder is active.";
       bitrate_allocator_->AddObserver(
           this, current_encoder_settings_->video_codec.minBitrate * 1000,
           current_encoder_settings_->video_codec.maxBitrate * 1000,
           CalulcateMaxPadBitrateBps(current_encoder_settings_->config,
                                     config_.suspend_below_min_bitrate),
           !config_.suspend_below_min_bitrate);
-      send_stream_registered_as_observer_ = true;
+      state_ = State::kStarted;
+    }
+
+    VideoFrame frame;
+    if (input_.GetVideoFrame(&frame)) {
+      // TODO(perkj): |pre_encode_callback| is only used by tests. Tests should
+      // register as a sink to the VideoSource instead.
+      if (config_.pre_encode_callback) {
+        config_.pre_encode_callback->OnFrame(frame);
+      }
+      vie_encoder_.EncodeVideoFrame(frame);
     }
   }
   vie_encoder_.DeRegisterExternalEncoder(config_.encoder_settings.payload_type);
 }
 
 void VideoSendStream::ReconfigureVideoEncoder(
     const VideoEncoderConfig& config) {
   TRACE_EVENT0("webrtc", "VideoSendStream::(Re)configureVideoEncoder");
   LOG(LS_INFO) << "(Re)configureVideoEncoder: " << config.ToString();
   RTC_DCHECK_GE(config_.rtp.ssrcs.size(), config.streams.size());
@@ skipping 185 matching lines @@
 }
 
 void VideoSendStream::OnBitrateUpdated(uint32_t bitrate_bps,
                                        uint8_t fraction_loss,
                                        int64_t rtt) {
   payload_router_.SetTargetSendBitrate(bitrate_bps);
   // Get the encoder target rate. It is the estimated network rate -
   // protection overhead.
   uint32_t encoder_target_rate = protection_bitrate_calculator_.SetTargetRates(
       bitrate_bps, stats_proxy_.GetSendFrameRate(), fraction_loss, rtt);
-
   vie_encoder_.OnBitrateUpdated(encoder_target_rate, fraction_loss, rtt);
 }
 
 int VideoSendStream::ProtectionRequest(const FecProtectionParams* delta_params,
                                        const FecProtectionParams* key_params,
                                        uint32_t* sent_video_rate_bps,
                                        uint32_t* sent_nack_rate_bps,
                                        uint32_t* sent_fec_rate_bps) {
   *sent_video_rate_bps = 0;
   *sent_nack_rate_bps = 0;
   *sent_fec_rate_bps = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     uint32_t not_used = 0;
     uint32_t module_video_rate = 0;
     uint32_t module_fec_rate = 0;
     uint32_t module_nack_rate = 0;
     rtp_rtcp->SetFecParameters(delta_params, key_params);
     rtp_rtcp->BitrateSent(&not_used, &module_video_rate, &module_fec_rate,
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc