Periodically update codec bit/frame rate settings.

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 177 matching lines @@
     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 VideoSendStream::DegradationPreference::kBalanced:
-        FALLTHROUGH();

[stefan-webrtc, 2017/05/23 17:03:20]

If we remove this I assume we should add a break insetad?

[sprang_webrtc, 2017/05/24 09:07:07]

FALLTHROUGH() macro is actually only there to prevent compiler warnings if we do
some action in one case clause and then want to fall through and do even more
actions in the next one. For a case like this, where to enums should do the
exact same thing we don't need this macro.

       case VideoSendStream::DegradationPreference::kMaintainFramerate:
         wants.max_framerate_fps = std::numeric_limits<int>::max();
         break;
       case VideoSendStream::DegradationPreference::kMaintainResolution:
         wants.max_pixel_count = std::numeric_limits<int>::max();
         wants.target_pixel_count.reset();
         break;
       case VideoSendStream::DegradationPreference::kDegradationDisabled:
         wants.max_pixel_count = std::numeric_limits<int>::max();
         wants.target_pixel_count.reset();
@@ skipping 460 matching lines @@
     LOG(LS_INFO) << "Dropping frame. Too large for target bitrate.";
     AdaptDown(kQuality);
     ++initial_rampup_;
     return;
   }
   initial_rampup_ = kMaxInitialFramedrop;
 
   int64_t now_ms = clock_->TimeInMilliseconds();
   if (pending_encoder_reconfiguration_) {
     ReconfigureEncoder();
+    last_parameters_update_ms_.emplace(now_ms);
   } else if (!last_parameters_update_ms_ ||
              now_ms - *last_parameters_update_ms_ >=
                  vcm::VCMProcessTimer::kDefaultProcessIntervalMs) {
     video_sender_.UpdateChannelParemeters(rate_allocator_.get(),
                                           bitrate_observer_);
+    last_parameters_update_ms_.emplace(now_ms);
   }
-  last_parameters_update_ms_.emplace(now_ms);
 
   if (EncoderPaused()) {
     TraceFrameDropStart();
     return;
   }
   TraceFrameDropEnd();
 
   TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", video_frame.render_time_ms(),
                           "Encode");
 
@@ skipping 101 matching lines @@
       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 VideoSendStream::DegradationPreference::kBalanced:
-      FALLTHROUGH();
     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;
@@ skipping 16 matching lines @@
   }
 
   if (reason == kCpu) {
     const int cpu_scale_counter = GetScaleCounters()[reason];
     if (cpu_scale_counter >= max_downgrades)
       return;
   }
 
   switch (degradation_preference_) {
     case VideoSendStream::DegradationPreference::kBalanced:
-      FALLTHROUGH();
     case VideoSendStream::DegradationPreference::kMaintainFramerate:
       if (!source_proxy_->RequestResolutionLowerThan(
               adaptation_request.input_pixel_count_)) {
         return;
       }
       LOG(LS_INFO) << "Scaling down resolution.";
       break;
     case VideoSendStream::DegradationPreference::kMaintainResolution:
       source_proxy_->RequestFramerateLowerThan(
           adaptation_request.framerate_fps_);
@@ skipping 34 matching lines @@
   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 VideoSendStream::DegradationPreference::kBalanced:
-      FALLTHROUGH();
     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 VideoSendStream::DegradationPreference::kMaintainResolution:
       // TODO(sprang): Don't request higher framerate if we are already at
       // max requested fps?
       break;
     case VideoSendStream::DegradationPreference::kDegradationDisabled:
       return;
   }
 
   // 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>& scale_counters = GetScaleCounters();
   const int scale_sum =
       std::accumulate(scale_counters.begin(), scale_counters.end(), 0);
   switch (degradation_preference_) {
     case VideoSendStream::DegradationPreference::kBalanced:
-      FALLTHROUGH();
     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.";
       }
@@ skipping 45 matching lines @@
 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