Fix nits in vie_encoder

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 199 matching lines @@
   }
 
   void RequestHigherResolutionThan(int pixel_count) {
     rtc::CritScope lock(&crit_);
     if (!IsResolutionScalingEnabledLocked()) {
       // This can happen since |degradation_preference_| is set on
       // libjingle's worker thread but the adaptation is done on the encoder
       // task queue.
       return;
     }
-    // The input video frame size will have a resolution with "one step up"
-    // pixels than |max_pixel_count_step_up| where "one step up" depends on
-    // how the source can scale the input frame size. We still cap the step up
-    // to be at most twice the number of pixels.
+    // On step down we request at most 3/5 the pixel count of the previous
+    // resolution, so in order to take "one step up" we request a resolution as
+    // close as possible to 5/3 of the current resolution. The actual pixel
+    // count selected depends on the capabilities of the source. In order to not
+    // take a too large step up, we cap the requested pixel count to be at most
+    // four time the current number of pixels.
     sink_wants_.target_pixel_count = rtc::Optional<int>((pixel_count * 5) / 3);
     sink_wants_.max_pixel_count = rtc::Optional<int>(pixel_count * 4);
     if (source_)
       source_->AddOrUpdateSink(vie_encoder_, sink_wants_);
   }
 
  private:
   bool IsResolutionScalingEnabledLocked() const
       EXCLUSIVE_LOCKS_REQUIRED(&crit_) {
     return degradation_preference_ !=
@@ skipping 500 matching lines @@
 
   if (stats_proxy_ && video_suspension_changed) {
     LOG(LS_INFO) << "Video suspend state changed to: "
                  << (video_is_suspended ? "suspended" : "not suspended");
     stats_proxy_->OnSuspendChange(video_is_suspended);
   }
 }
 
 void ViEEncoder::AdaptDown(AdaptReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
-  if (degradation_preference_ != DegradationPreference::kBalanced ||
-      !last_frame_info_) {
+  if (degradation_preference_ != DegradationPreference::kBalanced)
     return;
-  }
+  RTC_DCHECK(static_cast<bool>(last_frame_info_));
   int current_pixel_count = last_frame_info_->pixel_count();
   if (last_adaptation_request_ &&
       last_adaptation_request_->mode_ == AdaptationRequest::Mode::kAdaptDown &&
       current_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;
   }
   last_adaptation_request_.emplace(AdaptationRequest{
       current_pixel_count, AdaptationRequest::Mode::kAdaptDown});
@@ skipping 15 matching lines @@
   LOG(LS_INFO) << "Scaling down resolution.";
   for (size_t i = 0; i < kScaleReasonSize; ++i) {
     LOG(LS_INFO) << "Scaled " << scale_counter_[i]
                  << " times for reason: " << (i ? "cpu" : "quality");
   }
 }
 
 void ViEEncoder::AdaptUp(AdaptReason reason) {
   RTC_DCHECK_RUN_ON(&encoder_queue_);
   if (scale_counter_[reason] == 0 ||
-      degradation_preference_ != DegradationPreference::kBalanced ||
-      !last_frame_info_) {
+      degradation_preference_ != DegradationPreference::kBalanced) {
     return;
   }
   // Only scale if resolution is higher than last time we requested higher
   // resolution.
+  RTC_DCHECK(static_cast<bool>(last_frame_info_));
   int current_pixel_count = last_frame_info_->pixel_count();
   if (last_adaptation_request_ &&
       last_adaptation_request_->mode_ == AdaptationRequest::Mode::kAdaptUp &&
       current_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;
   }
   last_adaptation_request_.emplace(AdaptationRequest{
       current_pixel_count, AdaptationRequest::Mode::kAdaptUp});
@@ skipping 12 matching lines @@
   --scale_counter_[reason];
   source_proxy_->RequestHigherResolutionThan(current_pixel_count);
   LOG(LS_INFO) << "Scaling up resolution.";
   for (size_t i = 0; i < kScaleReasonSize; ++i) {
     LOG(LS_INFO) << "Scaled " << scale_counter_[i]
                  << " times for reason: " << (i ? "cpu" : "quality");
   }
 }
 
 }  // namespace webrtc