Move kMinPixelsPerFrame constant in VideoStreamEncoder to VideoEncoder::ScalingSettings.

webrtc/media/engine/videoencodersoftwarefallbackwrapper.cc

 /*
  *  Copyright (c) 2016 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 32 matching lines @@
   RTC_DCHECK(param_high_kbps);
   RTC_DCHECK(param_min_low_ms);
   std::string group =
       webrtc::field_trial::FindFullName(kVp8ForceFallbackEncoderFieldTrial);
   if (group.empty())
     return;
 
   int low_kbps;
   int high_kbps;
   int min_low_ms;
-  if (sscanf(group.c_str(), "Enabled-%d,%d,%d", &low_kbps, &high_kbps,
-             &min_low_ms) != 3) {
+  int min_pixels;
+  if (sscanf(group.c_str(), "Enabled-%d,%d,%d,%d", &low_kbps, &high_kbps,
+             &min_low_ms, &min_pixels) != 4) {
     LOG(LS_WARNING) << "Invalid number of forced fallback parameters provided.";
     return;
   }
-  if (min_low_ms <= 0 || low_kbps <= 0 || high_kbps <= low_kbps) {
+  if (min_low_ms <= 0 || min_pixels <= 0 || low_kbps <= 0 ||
+      high_kbps <= low_kbps) {
     LOG(LS_WARNING) << "Invalid forced fallback parameter value provided.";
     return;
   }
   *param_low_kbps = low_kbps;
   *param_high_kbps = high_kbps;
   *param_min_low_ms = min_low_ms;
 }
 }  // namespace
 
 VideoEncoderSoftwareFallbackWrapper::VideoEncoderSoftwareFallbackWrapper(
@@ skipping 169 matching lines @@
 }
 
 bool VideoEncoderSoftwareFallbackWrapper::SupportsNativeHandle() const {
   if (fallback_encoder_)
     return fallback_encoder_->SupportsNativeHandle();
   return encoder_->SupportsNativeHandle();
 }
 
 VideoEncoder::ScalingSettings
 VideoEncoderSoftwareFallbackWrapper::GetScalingSettings() const {
+  if (forced_fallback_possible_ && fallback_encoder_)
+    return fallback_encoder_->GetScalingSettings();
   return encoder_->GetScalingSettings();
 }
 
 const char *VideoEncoderSoftwareFallbackWrapper::ImplementationName() const {
   if (fallback_encoder_)
     return fallback_encoder_->ImplementationName();
   return encoder_->ImplementationName();
 }
 
 bool VideoEncoderSoftwareFallbackWrapper::IsForcedFallbackActive() const {
   return (forced_fallback_possible_ && fallback_encoder_ &&
           forced_fallback_.start_ms);
 }
 
 bool VideoEncoderSoftwareFallbackWrapper::RequestForcedFallback() {
   if (!forced_fallback_possible_ || fallback_encoder_ || !rates_set_)
     return false;
 
   // No fallback encoder.
   return forced_fallback_.ShouldStart(bitrate_allocation_.get_sum_kbps(),
                                       codec_settings_);
 }
 
 bool VideoEncoderSoftwareFallbackWrapper::TryReleaseForcedFallbackEncoder() {
   if (!IsForcedFallbackActive())
     return false;
 
-  if (!forced_fallback_.ShouldStop(bitrate_allocation_.get_sum_kbps()))
+  if (!forced_fallback_.ShouldStop(bitrate_allocation_.get_sum_kbps(),
+                                   codec_settings_)) {
     return false;
+  }
 
   // Release the forced fallback encoder.
   if (encoder_->InitEncode(&codec_settings_, number_of_cores_,
                            max_payload_size_) == WEBRTC_VIDEO_CODEC_OK) {
     LOG(LS_INFO) << "Stop forced SW encoder fallback, max bitrate exceeded.";
     fallback_encoder_->Release();
     fallback_encoder_.reset();
     forced_fallback_.Reset();
     return true;
   }
@@ skipping 49 matching lines @@
   if ((now_ms - *start_ms) >= min_low_ms) {
     LOG(LS_INFO) << "Request forced SW encoder fallback.";
     // In case the request fails, update time to avoid too frequent requests.
     start_ms.emplace(now_ms);
     return true;
   }
   return false;
 }
 
 bool VideoEncoderSoftwareFallbackWrapper::ForcedFallbackParams::ShouldStop(
-    uint32_t bitrate_kbps) const {
-  return bitrate_kbps >= high_kbps;
+    uint32_t bitrate_kbps,
+    const VideoCodec& codec) const {
+  return bitrate_kbps >= high_kbps &&
+         (codec.width * codec.height >= kMinPixelsStop);
 }
 
 }  // namespace webrtc