Implemented the GetSources() in native code.

webrtc/video/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 15 matching lines @@
 #include "webrtc/modules/video_coding/codecs/vp8/temporal_layers.h"
 #include "webrtc/modules/video_coding/include/video_codec_initializer.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/video/overuse_frame_detector.h"
 #include "webrtc/video/send_statistics_proxy.h"
 #include "webrtc/video_frame.h"
 namespace webrtc {
 
 namespace {
-using DegradationPreference = VideoSendStream::DegradationPreference;
 
 // Time interval for logging frame counts.
 const int64_t kFrameLogIntervalMs = 60000;
 
 // We will never ask for a resolution lower than this.
 // TODO(kthelgason): Lower this limit when better testing
 // on MediaCodec and fallback implementations are in place.
 // See https://bugs.chromium.org/p/webrtc/issues/detail?id=7206
 const int kMinPixelsPerFrame = 320 * 180;
 const int kMinFramerateFps = 2;
@@ skipping 98 matching lines @@
 };
 
 // VideoSourceProxy is responsible ensuring thread safety between calls to
 // ViEEncoder::SetSource that will happen on libjingle's worker thread when a
 // video capturer is connected to the encoder and the encoder task queue
 // (encoder_queue_) where the encoder reports its VideoSinkWants.
 class ViEEncoder::VideoSourceProxy {
  public:
   explicit VideoSourceProxy(ViEEncoder* vie_encoder)
       : vie_encoder_(vie_encoder),
-        degradation_preference_(DegradationPreference::kDegradationDisabled),
+        degradation_preference_(
+            VideoSendStream::DegradationPreference::kDegradationDisabled),
         source_(nullptr) {}
 
-  void SetSource(rtc::VideoSourceInterface<VideoFrame>* source,
-                 const DegradationPreference& degradation_preference) {
+  void SetSource(
+      rtc::VideoSourceInterface<VideoFrame>* source,
+      const VideoSendStream::DegradationPreference& degradation_preference) {
     // Called on libjingle's worker thread.
     RTC_DCHECK_CALLED_SEQUENTIALLY(&main_checker_);
     rtc::VideoSourceInterface<VideoFrame>* old_source = nullptr;
     rtc::VideoSinkWants wants;
     {
       rtc::CritScope lock(&crit_);
       degradation_preference_ = degradation_preference;
       old_source = source_;
       source_ = source;
       wants = GetActiveSinkWants();
@@ skipping 15 matching lines @@
     sink_wants_.rotation_applied = rotation_applied;
     if (source_)
       source_->AddOrUpdateSink(vie_encoder_, sink_wants_);
   }
 
   rtc::VideoSinkWants GetActiveSinkWants() EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
     rtc::VideoSinkWants wants = sink_wants_;
     // Clear any constraints from the current sink wants that don't apply to
     // the used degradation_preference.
     switch (degradation_preference_) {
-      case DegradationPreference::kBalanced:
+      case VideoSendStream::DegradationPreference::kBalanced:
         FALLTHROUGH();
-      case DegradationPreference::kMaintainFramerate:
+      case VideoSendStream::DegradationPreference::kMaintainFramerate:
         wants.max_framerate_fps = std::numeric_limits<int>::max();
         break;
-      case DegradationPreference::kMaintainResolution:
+      case VideoSendStream::DegradationPreference::kMaintainResolution:
         wants.max_pixel_count = std::numeric_limits<int>::max();
         wants.target_pixel_count.reset();
         break;
-      case DegradationPreference::kDegradationDisabled:
+      case VideoSendStream::DegradationPreference::kDegradationDisabled:
         wants.max_pixel_count = std::numeric_limits<int>::max();
         wants.target_pixel_count.reset();
         wants.max_framerate_fps = std::numeric_limits<int>::max();
     }
     return wants;
   }
 
   void RequestResolutionLowerThan(int pixel_count) {
     // Called on the encoder task queue.
     rtc::CritScope lock(&crit_);
@@ skipping 80 matching lines @@
       sink_wants_.max_framerate_fps = framerate_wanted;
     }
     if (source_)
       source_->AddOrUpdateSink(vie_encoder_, GetActiveSinkWants());
   }
 
  private:
   bool IsResolutionScalingEnabledLocked() const
       EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
     return degradation_preference_ ==
-               DegradationPreference::kMaintainFramerate ||
-           degradation_preference_ == DegradationPreference::kBalanced;
+               VideoSendStream::DegradationPreference::kMaintainFramerate ||
+           degradation_preference_ ==
+               VideoSendStream::DegradationPreference::kBalanced;
   }
 
   bool IsFramerateScalingEnabledLocked() const
       EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
     // TODO(sprang): Also accept kBalanced here?
     return degradation_preference_ ==
-           DegradationPreference::kMaintainResolution;
+           VideoSendStream::DegradationPreference::kMaintainResolution;
   }
 
   rtc::CriticalSection crit_;
   rtc::SequencedTaskChecker main_checker_;
   ViEEncoder* const vie_encoder_;
   rtc::VideoSinkWants sink_wants_ GUARDED_BY(&crit_);
-  DegradationPreference degradation_preference_ GUARDED_BY(&crit_);
+  VideoSendStream::DegradationPreference degradation_preference_
+      GUARDED_BY(&crit_);
   rtc::VideoSourceInterface<VideoFrame>* source_ GUARDED_BY(&crit_);
 
   RTC_DISALLOW_COPY_AND_ASSIGN(VideoSourceProxy);
 };
 
 ViEEncoder::ViEEncoder(uint32_t number_of_cores,
                        SendStatisticsProxy* stats_proxy,
                        const VideoSendStream::Config::EncoderSettings& settings,
                        rtc::VideoSinkInterface<VideoFrame>* pre_encode_callback,
                        EncodedFrameObserver* encoder_timing)
@@ skipping 13 matching lines @@
       stats_proxy_(stats_proxy),
       pre_encode_callback_(pre_encode_callback),
       module_process_thread_(nullptr),
       pending_encoder_reconfiguration_(false),
       encoder_start_bitrate_bps_(0),
       max_data_payload_length_(0),
       nack_enabled_(false),
       last_observed_bitrate_bps_(0),
       encoder_paused_and_dropped_frame_(false),
       clock_(Clock::GetRealTimeClock()),
-      degradation_preference_(DegradationPreference::kDegradationDisabled),
+      degradation_preference_(
+          VideoSendStream::DegradationPreference::kDegradationDisabled),
       last_captured_timestamp_(0),
       delta_ntp_internal_ms_(clock_->CurrentNtpInMilliseconds() -
                              clock_->TimeInMilliseconds()),
       last_frame_log_ms_(clock_->TimeInMilliseconds()),
       captured_frame_count_(0),
       dropped_frame_count_(0),
       bitrate_observer_(nullptr),
       encoder_queue_("EncoderQueue") {
   RTC_DCHECK(stats_proxy);
   encoder_queue_.PostTask([this] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     overuse_detector_.StartCheckForOveruse();
     video_sender_.RegisterExternalEncoder(
         settings_.encoder, settings_.payload_type, settings_.internal_source);
   });
 }
 
 ViEEncoder::~ViEEncoder() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   RTC_DCHECK(shutdown_event_.Wait(0))
       << "Must call ::Stop() before destruction.";
 }
 
 void ViEEncoder::Stop() {
   RTC_DCHECK_RUN_ON(&thread_checker_);
-  source_proxy_->SetSource(nullptr, DegradationPreference());
+  source_proxy_->SetSource(nullptr, VideoSendStream::DegradationPreference());
   encoder_queue_.PostTask([this] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     overuse_detector_.StopCheckForOveruse();
     rate_allocator_.reset();
     bitrate_observer_ = nullptr;
     video_sender_.RegisterExternalEncoder(nullptr, settings_.payload_type,
                                           false);
     quality_scaler_ = nullptr;
     shutdown_event_.Set();
   });
@@ skipping 19 matching lines @@
   RTC_DCHECK_RUN_ON(&thread_checker_);
   encoder_queue_.PostTask([this, bitrate_observer] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     RTC_DCHECK(!bitrate_observer_);
     bitrate_observer_ = bitrate_observer;
   });
 }
 
 void ViEEncoder::SetSource(
     rtc::VideoSourceInterface<VideoFrame>* source,
-    const VideoSendStream::DegradationPreference& degradation_preference) {
+    const VideoSendStream::VideoSendStream::DegradationPreference&
+        degradation_preference) {
   RTC_DCHECK_RUN_ON(&thread_checker_);
   source_proxy_->SetSource(source, degradation_preference);
   encoder_queue_.PostTask([this, degradation_preference] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     if (degradation_preference_ != degradation_preference) {
       // Reset adaptation state, so that we're not tricked into thinking there's
       // an already pending request of the same type.
       last_adaptation_request_.reset();
     }
     degradation_preference_ = degradation_preference;
     bool allow_scaling =
-        degradation_preference_ == DegradationPreference::kMaintainFramerate ||
-        degradation_preference_ == DegradationPreference::kBalanced;
+        degradation_preference_ ==
+            VideoSendStream::DegradationPreference::kMaintainFramerate ||
+        degradation_preference_ ==
+            VideoSendStream::DegradationPreference::kBalanced;
     initial_rampup_ = allow_scaling ? 0 : kMaxInitialFramedrop;
     ConfigureQualityScaler();
   });
 }
 
 void ViEEncoder::SetSink(EncoderSink* sink, bool rotation_applied) {
   source_proxy_->SetWantsRotationApplied(rotation_applied);
   encoder_queue_.PostTask([this, sink] {
     RTC_DCHECK_RUN_ON(&encoder_queue_);
     sink_ = sink;
@@ skipping 83 matching lines @@
   sink_->OnEncoderConfigurationChanged(
       std::move(streams), encoder_config_.min_transmit_bitrate_bps);
 
   ConfigureQualityScaler();
 }
 
 void ViEEncoder::ConfigureQualityScaler() {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   const auto scaling_settings = settings_.encoder->GetScalingSettings();
   const bool degradation_preference_allows_scaling =
-      degradation_preference_ == DegradationPreference::kMaintainFramerate ||
-      degradation_preference_ == DegradationPreference::kBalanced;
+      degradation_preference_ ==
+          VideoSendStream::DegradationPreference::kMaintainFramerate ||
+      degradation_preference_ ==
+          VideoSendStream::DegradationPreference::kBalanced;
   const bool quality_scaling_allowed =
       degradation_preference_allows_scaling && scaling_settings.enabled;
 
   const std::vector<int>& scale_counters = GetScaleCounters();
   stats_proxy_->SetCpuScalingStats(
       degradation_preference_allows_scaling ? scale_counters[kCpu] > 0 : false);
   stats_proxy_->SetQualityScalingStats(
       quality_scaling_allowed ? scale_counters[kQuality] : -1);
 
   if (quality_scaling_allowed) {
@@ skipping 242 matching lines @@
   AdaptationRequest adaptation_request = {
       last_frame_info_->pixel_count(),
       stats_proxy_->GetStats().input_frame_rate,
       AdaptationRequest::Mode::kAdaptDown};
   bool downgrade_requested =
       last_adaptation_request_ &&
       last_adaptation_request_->mode_ == AdaptationRequest::Mode::kAdaptDown;
 
   int max_downgrades = 0;
   switch (degradation_preference_) {
-    case DegradationPreference::kBalanced:
+    case VideoSendStream::DegradationPreference::kBalanced:
       FALLTHROUGH();
-    case DegradationPreference::kMaintainFramerate:
+    case VideoSendStream::DegradationPreference::kMaintainFramerate:
       max_downgrades = kMaxCpuResolutionDowngrades;
       if (downgrade_requested &&
           adaptation_request.input_pixel_count_ >=
               last_adaptation_request_->input_pixel_count_) {
         // Don't request lower resolution if the current resolution is not
         // lower than the last time we asked for the resolution to be lowered.
         return;
       }
       break;
-    case DegradationPreference::kMaintainResolution:
+    case VideoSendStream::DegradationPreference::kMaintainResolution:
       max_downgrades = kMaxCpuFramerateDowngrades;
       if (adaptation_request.framerate_fps_ <= 0 ||
           (downgrade_requested &&
            adaptation_request.framerate_fps_ < kMinFramerateFps)) {
         // If no input fps estimate available, can't determine how to scale down
         // framerate. Otherwise, don't request lower framerate if we don't have
         // a valid frame rate. Since framerate, unlike resolution, is a measure
         // we have to estimate, and can fluctuate naturally over time, don't
         // make the same kind of limitations as for resolution, but trust the
         // overuse detector to not trigger too often.
         return;
       }
       break;
-    case DegradationPreference::kDegradationDisabled:
+    case VideoSendStream::DegradationPreference::kDegradationDisabled:
       return;
   }
 
   last_adaptation_request_.emplace(adaptation_request);
   const std::vector<int>& scale_counter = GetScaleCounters();
 
   switch (reason) {
     case kQuality:
       stats_proxy_->OnQualityRestrictedResolutionChanged(scale_counter[reason] +
                                                          1);
       break;
     case kCpu:
       if (scale_counter[reason] >= max_downgrades)
         return;
       // Update stats accordingly.
       stats_proxy_->OnCpuRestrictedResolutionChanged(true);
       break;
   }
 
   IncrementScaleCounter(reason, 1);
 
   switch (degradation_preference_) {
-    case DegradationPreference::kBalanced:
+    case VideoSendStream::DegradationPreference::kBalanced:
       FALLTHROUGH();
-    case DegradationPreference::kMaintainFramerate:
+    case VideoSendStream::DegradationPreference::kMaintainFramerate:
       source_proxy_->RequestResolutionLowerThan(
           adaptation_request.input_pixel_count_);
       LOG(LS_INFO) << "Scaling down resolution.";
       break;
-    case DegradationPreference::kMaintainResolution:
+    case VideoSendStream::DegradationPreference::kMaintainResolution:
       source_proxy_->RequestFramerateLowerThan(
           adaptation_request.framerate_fps_);
       LOG(LS_INFO) << "Scaling down framerate.";
       break;
-    case DegradationPreference::kDegradationDisabled:
+    case VideoSendStream::DegradationPreference::kDegradationDisabled:
       RTC_NOTREACHED();
   }
 
   for (size_t i = 0; i < kScaleReasonSize; ++i) {
     LOG(LS_INFO) << "Scaled " << GetScaleCounters()[i]
                  << " times for reason: " << (i ? "cpu" : "quality");
   }
 }
 
 void ViEEncoder::AdaptUp(AdaptReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   int scale_counter = GetScaleCounters()[reason];
   if (scale_counter == 0)
     return;
   RTC_DCHECK_GT(scale_counter, 0);
   AdaptationRequest adaptation_request = {
       last_frame_info_->pixel_count(),
       stats_proxy_->GetStats().input_frame_rate,
       AdaptationRequest::Mode::kAdaptUp};
 
   bool adapt_up_requested =
       last_adaptation_request_ &&
       last_adaptation_request_->mode_ == AdaptationRequest::Mode::kAdaptUp;
   switch (degradation_preference_) {
-    case DegradationPreference::kBalanced:
+    case VideoSendStream::DegradationPreference::kBalanced:
       FALLTHROUGH();
-    case DegradationPreference::kMaintainFramerate:
+    case VideoSendStream::DegradationPreference::kMaintainFramerate:
       if (adapt_up_requested &&
           adaptation_request.input_pixel_count_ <=
               last_adaptation_request_->input_pixel_count_) {
         // Don't request higher resolution if the current resolution is not
         // higher than the last time we asked for the resolution to be higher.
         return;
       }
       break;
-    case DegradationPreference::kMaintainResolution:
+    case VideoSendStream::DegradationPreference::kMaintainResolution:
       // TODO(sprang): Don't request higher framerate if we are already at
       // max requested fps?
       break;
-    case DegradationPreference::kDegradationDisabled:
+    case VideoSendStream::DegradationPreference::kDegradationDisabled:
       return;
   }
 
   last_adaptation_request_.emplace(adaptation_request);
 
   switch (reason) {
     case kQuality:
       stats_proxy_->OnQualityRestrictedResolutionChanged(scale_counter - 1);
       break;
     case kCpu:
       // Update stats accordingly.
       stats_proxy_->OnCpuRestrictedResolutionChanged(scale_counter > 1);
       break;
   }
 
   // Decrease counter of how many times we have scaled down, for this
   // degradation preference mode and reason.
   IncrementScaleCounter(reason, -1);
 
   // Get a sum of how many times have scaled down, in total, for this
   // degradation preference mode. If it is 0, remove any restraints.
   const std::vector<int>& current_scale_counters = GetScaleCounters();
   const int scale_sum = std::accumulate(current_scale_counters.begin(),
                                         current_scale_counters.end(), 0);
   switch (degradation_preference_) {
-    case DegradationPreference::kBalanced:
+    case VideoSendStream::DegradationPreference::kBalanced:
       FALLTHROUGH();
-    case DegradationPreference::kMaintainFramerate:
+    case VideoSendStream::DegradationPreference::kMaintainFramerate:
       if (scale_sum == 0) {
         LOG(LS_INFO) << "Removing resolution down-scaling setting.";
         source_proxy_->RequestHigherResolutionThan(
             std::numeric_limits<int>::max());
       } else {
         source_proxy_->RequestHigherResolutionThan(
             adaptation_request.input_pixel_count_);
         LOG(LS_INFO) << "Scaling up resolution.";
       }
       break;
-    case DegradationPreference::kMaintainResolution:
+    case VideoSendStream::DegradationPreference::kMaintainResolution:
       if (scale_sum == 0) {
         LOG(LS_INFO) << "Removing framerate down-scaling setting.";
         source_proxy_->RequestHigherFramerateThan(
             std::numeric_limits<int>::max());
       } else {
         source_proxy_->RequestHigherFramerateThan(
             adaptation_request.framerate_fps_);
         LOG(LS_INFO) << "Scaling up framerate.";
       }
       break;
-    case DegradationPreference::kDegradationDisabled:
+    case VideoSendStream::DegradationPreference::kDegradationDisabled:
       RTC_NOTREACHED();
   }
 
   for (size_t i = 0; i < kScaleReasonSize; ++i) {
     LOG(LS_INFO) << "Scaled " << current_scale_counters[i]
                  << " times for reason: " << (i ? "cpu" : "quality");
   }
 }
 
 const std::vector<int>& ViEEncoder::GetScaleCounters() {
   auto it = scale_counters_.find(degradation_preference_);
   if (it == scale_counters_.end()) {
     scale_counters_[degradation_preference_].resize(kScaleReasonSize);
     return scale_counters_[degradation_preference_];
   }
   return it->second;
 }
 
 void ViEEncoder::IncrementScaleCounter(int reason, int delta) {
   // Get the counters and validate. This may also lazily initialize the state.
   const std::vector<int>& counter = GetScaleCounters();
   if (delta < 0) {
     RTC_DCHECK_GE(counter[reason], delta);
   }
   scale_counters_[degradation_preference_][reason] += delta;
 }
 
 }  // namespace webrtc