Rename ViEEncoder to VideoStreamEncoder.

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.
  */
 #include "webrtc/video/video_send_stream.h"
@@ skipping 315 matching lines @@
 // VideoSendStreamImpl implements internal::VideoSendStream.
 // It is created and destroyed on |worker_queue|. The intent is to decrease the
 // need for locking and to ensure methods are called in sequence.
 // Public methods except |DeliverRtcp| must be called on |worker_queue|.
 // DeliverRtcp is called on the libjingle worker thread or a network thread.
 // An encoder may deliver frames through the EncodedImageCallback on an
 // arbitrary thread.
 class VideoSendStreamImpl : public webrtc::BitrateAllocatorObserver,
                             public webrtc::OverheadObserver,
                             public webrtc::VCMProtectionCallback,
-                            public ViEEncoder::EncoderSink,
+                            public VideoStreamEncoder::EncoderSink,
                             public VideoBitrateAllocationObserver {
  public:
   VideoSendStreamImpl(SendStatisticsProxy* stats_proxy,
                       rtc::TaskQueue* worker_queue,
                       CallStats* call_stats,
                       RtpTransportControllerSendInterface* transport,
                       BitrateAllocator* bitrate_allocator,
                       SendDelayStats* send_delay_stats,
-                      ViEEncoder* vie_encoder,
+                      VideoStreamEncoder* video_stream_encoder,
                       RtcEventLog* event_log,
                       const VideoSendStream::Config* config,
                       int initial_encoder_max_bitrate,
                       std::map<uint32_t, RtpState> suspended_ssrcs,
                       VideoEncoderConfig::ContentType content_type,
                       const RtpKeepAliveConfig& keepalive_config);
   ~VideoSendStreamImpl() override;
 
   // RegisterProcessThread register |module_process_thread| with those objects
   // that use it. Registration has to happen on the thread were
@@ skipping 77 matching lines @@
 
   rtc::CriticalSection ivf_writers_crit_;
   std::unique_ptr<IvfFileWriter> file_writers_[kMaxSimulcastStreams] GUARDED_BY(
       ivf_writers_crit_);
 
   int max_padding_bitrate_;
   int encoder_min_bitrate_bps_;
   uint32_t encoder_max_bitrate_bps_;
   uint32_t encoder_target_rate_bps_;
 
-  ViEEncoder* const vie_encoder_;
+  VideoStreamEncoder* const video_stream_encoder_;
   EncoderRtcpFeedback encoder_feedback_;
   ProtectionBitrateCalculator protection_bitrate_calculator_;
 
   const std::unique_ptr<RtcpBandwidthObserver> bandwidth_observer_;
   // RtpRtcp modules, declared here as they use other members on construction.
   const std::vector<RtpRtcp*> rtp_rtcp_modules_;
   PayloadRouter payload_router_;
 
   // |weak_ptr_| to our self. This is used since we can not call
   // |weak_ptr_factory_.GetWeakPtr| from multiple sequences but it is ok to copy
   // an existing WeakPtr.
   rtc::WeakPtr<VideoSendStreamImpl> weak_ptr_;
   // |weak_ptr_factory_| must be declared last to make sure all WeakPtr's are
   // invalidated before any other members are destroyed.
   rtc::WeakPtrFactory<VideoSendStreamImpl> weak_ptr_factory_;
 
   rtc::CriticalSection overhead_bytes_per_packet_crit_;
   size_t overhead_bytes_per_packet_ GUARDED_BY(overhead_bytes_per_packet_crit_);
   size_t transport_overhead_bytes_per_packet_;
 };
 
 // TODO(tommi): See if there's a more elegant way to create a task that creates
 // an object on the correct task queue.
 class VideoSendStream::ConstructionTask : public rtc::QueuedTask {
  public:
   ConstructionTask(std::unique_ptr<VideoSendStreamImpl>* send_stream,
                    rtc::Event* done_event,
                    SendStatisticsProxy* stats_proxy,
-                   ViEEncoder* vie_encoder,
+                   VideoStreamEncoder* video_stream_encoder,
                    ProcessThread* module_process_thread,
                    CallStats* call_stats,
                    RtpTransportControllerSendInterface* transport,
                    BitrateAllocator* bitrate_allocator,
                    SendDelayStats* send_delay_stats,
                    RtcEventLog* event_log,
                    const VideoSendStream::Config* config,
                    int initial_encoder_max_bitrate,
                    const std::map<uint32_t, RtpState>& suspended_ssrcs,
                    VideoEncoderConfig::ContentType content_type,
                    const RtpKeepAliveConfig& keepalive_config)
       : send_stream_(send_stream),
         done_event_(done_event),
         stats_proxy_(stats_proxy),
-        vie_encoder_(vie_encoder),
+        video_stream_encoder_(video_stream_encoder),
         call_stats_(call_stats),
         transport_(transport),
         bitrate_allocator_(bitrate_allocator),
         send_delay_stats_(send_delay_stats),
         event_log_(event_log),
         config_(config),
         initial_encoder_max_bitrate_(initial_encoder_max_bitrate),
         suspended_ssrcs_(suspended_ssrcs),
         content_type_(content_type),
         keepalive_config_(keepalive_config) {}
 
   ~ConstructionTask() override { done_event_->Set(); }
 
  private:
   bool Run() override {
     send_stream_->reset(new VideoSendStreamImpl(
         stats_proxy_, rtc::TaskQueue::Current(), call_stats_, transport_,
-        bitrate_allocator_, send_delay_stats_, vie_encoder_, event_log_,
-        config_, initial_encoder_max_bitrate_, std::move(suspended_ssrcs_),
-        content_type_, keepalive_config_));
+        bitrate_allocator_, send_delay_stats_, video_stream_encoder_,
+        event_log_, config_, initial_encoder_max_bitrate_,
+        std::move(suspended_ssrcs_), content_type_, keepalive_config_));
     return true;
   }
 
   std::unique_ptr<VideoSendStreamImpl>* const send_stream_;
   rtc::Event* const done_event_;
   SendStatisticsProxy* const stats_proxy_;
-  ViEEncoder* const vie_encoder_;
+  VideoStreamEncoder* const video_stream_encoder_;
   CallStats* const call_stats_;
   RtpTransportControllerSendInterface* const transport_;
   BitrateAllocator* const bitrate_allocator_;
   SendDelayStats* const send_delay_stats_;
   RtcEventLog* const event_log_;
   const VideoSendStream::Config* config_;
   int initial_encoder_max_bitrate_;
   std::map<uint32_t, RtpState> suspended_ssrcs_;
   const VideoEncoderConfig::ContentType content_type_;
   const RtpKeepAliveConfig& keepalive_config_;
@@ skipping 111 matching lines @@
     VideoEncoderConfig encoder_config,
     const std::map<uint32_t, RtpState>& suspended_ssrcs,
     const RtpKeepAliveConfig& keepalive_config)
     : worker_queue_(worker_queue),
       thread_sync_event_(false /* manual_reset */, false),
       stats_proxy_(Clock::GetRealTimeClock(),
                    config,
                    encoder_config.content_type),
       config_(std::move(config)),
       content_type_(encoder_config.content_type) {
-  vie_encoder_.reset(
-      new ViEEncoder(num_cpu_cores, &stats_proxy_, config_.encoder_settings,
-                     config_.pre_encode_callback, config_.post_encode_callback,
-                     std::unique_ptr<OveruseFrameDetector>()));
+  video_stream_encoder_.reset(
+      new VideoStreamEncoder(num_cpu_cores, &stats_proxy_,
+                             config_.encoder_settings,
+                             config_.pre_encode_callback,
+                             config_.post_encode_callback,
+                             std::unique_ptr<OveruseFrameDetector>()));
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(new ConstructionTask(
-      &send_stream_, &thread_sync_event_, &stats_proxy_, vie_encoder_.get(),
-      module_process_thread, call_stats, transport, bitrate_allocator,
-      send_delay_stats, event_log, &config_, encoder_config.max_bitrate_bps,
-      suspended_ssrcs, encoder_config.content_type, keepalive_config)));
+      &send_stream_, &thread_sync_event_, &stats_proxy_,
+      video_stream_encoder_.get(), module_process_thread, call_stats, transport,
+      bitrate_allocator, send_delay_stats, event_log, &config_,
+      encoder_config.max_bitrate_bps, suspended_ssrcs,
+      encoder_config.content_type, keepalive_config)));
 
   // Wait for ConstructionTask to complete so that |send_stream_| can be used.
   // |module_process_thread| must be registered and deregistered on the thread
   // it was created on.
   thread_sync_event_.Wait(rtc::Event::kForever);
   send_stream_->RegisterProcessThread(module_process_thread);
   // TODO(sprang): Enable this also for regular video calls if it works well.
   if (encoder_config.content_type == VideoEncoderConfig::ContentType::kScreen) {
     // Only signal target bitrate for screenshare streams, for now.
-    vie_encoder_->SetBitrateObserver(send_stream_.get());
+    video_stream_encoder_->SetBitrateObserver(send_stream_.get());
   }
-  vie_encoder_->RegisterProcessThread(module_process_thread);
+  video_stream_encoder_->RegisterProcessThread(module_process_thread);
 
   ReconfigureVideoEncoder(std::move(encoder_config));
 }
 
 VideoSendStream::~VideoSendStream() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   RTC_DCHECK(!send_stream_);
 }
 
 void VideoSendStream::Start() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   LOG(LS_INFO) << "VideoSendStream::Start";
   VideoSendStreamImpl* send_stream = send_stream_.get();
   worker_queue_->PostTask([this, send_stream] {
     send_stream->Start();
     thread_sync_event_.Set();
   });
 
   // It is expected that after VideoSendStream::Start has been called, incoming
-  // frames are not dropped in ViEEncoder. To ensure this, Start has to be
-  // synchronized.
+  // frames are not dropped in VideoStreamEncoder. To ensure this, Start has to
+  // be synchronized.
   thread_sync_event_.Wait(rtc::Event::kForever);
 }
 
 void VideoSendStream::Stop() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   LOG(LS_INFO) << "VideoSendStream::Stop";
   VideoSendStreamImpl* send_stream = send_stream_.get();
   worker_queue_->PostTask([send_stream] { send_stream->Stop(); });
 }
 
 void VideoSendStream::SetSource(
     rtc::VideoSourceInterface<webrtc::VideoFrame>* source,
     const DegradationPreference& degradation_preference) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
-  vie_encoder_->SetSource(source, degradation_preference);
+  video_stream_encoder_->SetSource(source, degradation_preference);
 }
 
 void VideoSendStream::ReconfigureVideoEncoder(VideoEncoderConfig config) {
   // TODO(perkj): Some test cases in VideoSendStreamTest call
   // ReconfigureVideoEncoder from the network thread.
   // RTC_DCHECK_RUN_ON(&thread_checker_);
   RTC_DCHECK(content_type_ == config.content_type);
-  vie_encoder_->ConfigureEncoder(std::move(config), config_.rtp.max_packet_size,
-                                 config_.rtp.nack.rtp_history_ms > 0);
+  video_stream_encoder_->ConfigureEncoder(std::move(config),
+                                          config_.rtp.max_packet_size,
+                                          config_.rtp.nack.rtp_history_ms > 0);
 }
 
 VideoSendStream::Stats VideoSendStream::GetStats() {
   // TODO(perkj, solenberg): Some test cases in EndToEndTest call GetStats from
   // a network thread. See comment in Call::GetStats().
   // RTC_DCHECK_RUN_ON(&thread_checker_);
   return stats_proxy_.GetStats();
 }
 
 void VideoSendStream::SignalNetworkState(NetworkState state) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   VideoSendStreamImpl* send_stream = send_stream_.get();
   worker_queue_->PostTask(
       [send_stream, state] { send_stream->SignalNetworkState(state); });
 }
 
 VideoSendStream::RtpStateMap VideoSendStream::StopPermanentlyAndGetRtpStates() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
-  vie_encoder_->Stop();
-  vie_encoder_->DeRegisterProcessThread();
+  video_stream_encoder_->Stop();
+  video_stream_encoder_->DeRegisterProcessThread();
   VideoSendStream::RtpStateMap state_map;
   send_stream_->DeRegisterProcessThread();
   worker_queue_->PostTask(
       std::unique_ptr<rtc::QueuedTask>(new DestructAndGetRtpStateTask(
           &state_map, std::move(send_stream_), &thread_sync_event_)));
   thread_sync_event_.Wait(rtc::Event::kForever);
   return state_map;
 }
 
 void VideoSendStream::SetTransportOverhead(
@@ skipping 16 matching lines @@
   send_stream_->EnableEncodedFrameRecording(files, byte_limit);
 }
 
 VideoSendStreamImpl::VideoSendStreamImpl(
     SendStatisticsProxy* stats_proxy,
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
     RtpTransportControllerSendInterface* transport,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
-    ViEEncoder* vie_encoder,
+    VideoStreamEncoder* video_stream_encoder,
     RtcEventLog* event_log,
     const VideoSendStream::Config* config,
     int initial_encoder_max_bitrate,
     std::map<uint32_t, RtpState> suspended_ssrcs,
     VideoEncoderConfig::ContentType content_type,
     const RtpKeepAliveConfig& keepalive_config)
     : send_side_bwe_with_overhead_(
           webrtc::field_trial::IsEnabled("WebRTC-SendSideBwe-WithOverhead")),
       stats_proxy_(stats_proxy),
       config_(config),
       suspended_ssrcs_(std::move(suspended_ssrcs)),
       module_process_thread_(nullptr),
       worker_queue_(worker_queue),
       check_encoder_activity_task_(nullptr),
       call_stats_(call_stats),
       transport_(transport),
       bitrate_allocator_(bitrate_allocator),
       flexfec_sender_(MaybeCreateFlexfecSender(*config_, suspended_ssrcs_)),
       max_padding_bitrate_(0),
       encoder_min_bitrate_bps_(0),
       encoder_max_bitrate_bps_(initial_encoder_max_bitrate),
       encoder_target_rate_bps_(0),
-      vie_encoder_(vie_encoder),
+      video_stream_encoder_(video_stream_encoder),
       encoder_feedback_(Clock::GetRealTimeClock(),
                         config_->rtp.ssrcs,
-                        vie_encoder),
+                        video_stream_encoder),
       protection_bitrate_calculator_(Clock::GetRealTimeClock(), this),
       bandwidth_observer_(transport->send_side_cc()
                               ->GetBitrateController()
                               ->CreateRtcpBandwidthObserver()),
       rtp_rtcp_modules_(CreateRtpRtcpModules(
           config_->send_transport,
           &encoder_feedback_,
           bandwidth_observer_.get(),
           transport,
           call_stats_->rtcp_rtt_stats(),
@@ skipping 75 matching lines @@
     rtp_rtcp->SetMaxRtpPacketSize(config_->rtp.max_packet_size);
     rtp_rtcp->RegisterVideoSendPayload(
         config_->encoder_settings.payload_type,
         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);
 
-  vie_encoder_->SetStartBitrate(bitrate_allocator_->GetStartBitrate(this));
+  video_stream_encoder_->SetStartBitrate(
+      bitrate_allocator_->GetStartBitrate(this));
 
   // Only request rotation at the source when we positively know that the remote
   // side doesn't support the rotation extension. This allows us to prepare the
   // encoder in the expectation that rotation is supported - which is the common
   // case.
   bool rotation_applied =
       std::find_if(config_->rtp.extensions.begin(),
                    config_->rtp.extensions.end(),
                    [](const RtpExtension& extension) {
                      return extension.uri == RtpExtension::kVideoRotationUri;
                    }) == config_->rtp.extensions.end();
 
-  vie_encoder_->SetSink(this, rotation_applied);
+  video_stream_encoder_->SetSink(this, rotation_applied);
 }
 
 void VideoSendStreamImpl::RegisterProcessThread(
     ProcessThread* module_process_thread) {
   RTC_DCHECK_RUN_ON(&module_process_thread_checker_);
   RTC_DCHECK(!module_process_thread_);
   module_process_thread_ = module_process_thread;
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_)
     module_process_thread_->RegisterModule(rtp_rtcp, RTC_FROM_HERE);
@@ skipping 40 matching lines @@
   // Start monitoring encoder activity.
   {
     rtc::CritScope lock(&encoder_activity_crit_sect_);
     RTC_DCHECK(!check_encoder_activity_task_);
     check_encoder_activity_task_ = new CheckEncoderActivityTask(weak_ptr_);
     worker_queue_->PostDelayedTask(
         std::unique_ptr<rtc::QueuedTask>(check_encoder_activity_task_),
         CheckEncoderActivityTask::kEncoderTimeOutMs);
   }
 
-  vie_encoder_->SendKeyFrame();
+  video_stream_encoder_->SendKeyFrame();
 }
 
 void VideoSendStreamImpl::Stop() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   LOG(LS_INFO) << "VideoSendStream::Stop";
   if (!payload_router_.IsActive())
     return;
   TRACE_EVENT_INSTANT0("webrtc", "VideoSendStream::Stop");
   payload_router_.SetActive(false);
   bitrate_allocator_->RemoveObserver(this);
   {
     rtc::CritScope lock(&encoder_activity_crit_sect_);
     check_encoder_activity_task_->Stop();
     check_encoder_activity_task_ = nullptr;
   }
-  vie_encoder_->OnBitrateUpdated(0, 0, 0);
+  video_stream_encoder_->OnBitrateUpdated(0, 0, 0);
   stats_proxy_->OnSetEncoderTargetRate(0);
 }
 
 void VideoSendStreamImpl::SignalEncoderTimedOut() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   // If the encoder has not produced anything the last kEncoderTimeOutMs and it
   // is supposed to, deregister as BitrateAllocatorObserver. This can happen
   // if a camera stops producing frames.
   if (encoder_target_rate_bps_ > 0) {
     LOG(LS_INFO) << "SignalEncoderTimedOut, Encoder timed out.";
@@ skipping 300 matching lines @@
                 bitrate_bps - encoder_target_rate_bps_)
           : 0;
 
   // When the field trial "WebRTC-SendSideBwe-WithOverhead" is enabled
   // protection_bitrate includes overhead.
   uint32_t protection_bitrate =
       bitrate_bps - (encoder_target_rate_bps_ + encoder_overhead_rate_bps);
 
   encoder_target_rate_bps_ =
       std::min(encoder_max_bitrate_bps_, encoder_target_rate_bps_);
-  vie_encoder_->OnBitrateUpdated(encoder_target_rate_bps_, fraction_loss, rtt);
+  video_stream_encoder_->OnBitrateUpdated(encoder_target_rate_bps_,
+                                          fraction_loss, rtt);
   stats_proxy_->OnSetEncoderTargetRate(encoder_target_rate_bps_);
   return protection_bitrate;
 }
 
 void VideoSendStreamImpl::EnableEncodedFrameRecording(
     const std::vector<rtc::PlatformFile>& files,
     size_t byte_limit) {
   {
     rtc::CritScope lock(&ivf_writers_crit_);
     for (unsigned int i = 0; i < kMaxSimulcastStreams; ++i) {
       if (i < files.size()) {
         file_writers_[i] = IvfFileWriter::Wrap(rtc::File(files[i]), byte_limit);
       } else {
         file_writers_[i].reset();
       }
     }
   }
 
   if (!files.empty()) {
     // Make a keyframe appear as early as possible in the logs, to give actually
     // decodable output.
-    vie_encoder_->SendKeyFrame();
+    video_stream_encoder_->SendKeyFrame();
   }
 }
 
 int VideoSendStreamImpl::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) {
   RTC_DCHECK_RUN_ON(worker_queue_);
@@ skipping 36 matching lines @@
       std::min(config_->rtp.max_packet_size,
                kPathMTU - transport_overhead_bytes_per_packet_);
 
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     rtp_rtcp->SetMaxRtpPacketSize(rtp_packet_size);
   }
 }
 
 }  // namespace internal
 }  // namespace webrtc