Cleanup the VideoAdapter

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 1807 matching lines @@
       recreate_stream = false;  // SetCodec has already recreated the stream.
     } else if (params.conference_mode && parameters_.codec_settings) {
       SetCodec(*parameters_.codec_settings);
       recreate_stream = false;  // SetCodec has already recreated the stream.
     }
     if (recreate_stream) {
       LOG(LS_INFO)
           << "RecreateWebRtcStream (send) because of SetSendParameters";
       RecreateWebRtcStream();
     }
-  } // release |lock_|
+  }  // release |lock_|
 
   // |capturer_->AddOrUpdateSink| may not be called while holding |lock_| since
   // that might cause a lock order inversion.
   if (params.rtp_header_extensions) {
     sink_wants_.rotation_applied = !ContainsHeaderExtension(
         *params.rtp_header_extensions, kRtpVideoRotationHeaderExtension);
     if (capturer_) {
       capturer_->AddOrUpdateSink(this, sink_wants_);
     }
   }
@@ skipping 170 matching lines @@
                                                                : "false")
                          : "unset");
     // Do not adapt resolution for screen content as this will likely result in
     // blurry and unreadable text.
     if (parameters_.options.is_screencast.value_or(false))
       return;
 
     rtc::Optional<int> max_pixel_count;
     rtc::Optional<int> max_pixel_count_step_up;
     if (load == kOveruse) {
-        max_pixel_count = rtc::Optional<int>(
-            (last_dimensions_.height * last_dimensions_.width) / 2);
+      max_pixel_count = rtc::Optional<int>(
+          (last_dimensions_.height * last_dimensions_.width * 3) / 5);
       // Increase |number_of_cpu_adapt_changes_| if
       // sink_wants_.max_pixel_count will be changed since
       // last time |capturer_->AddOrUpdateSink| was called. That is, this will
       // result in a new request for the capturer to change resolution.
       if (!sink_wants_.max_pixel_count ||
           *sink_wants_.max_pixel_count > *max_pixel_count) {
         ++number_of_cpu_adapt_changes_;
         ++cpu_restricted_counter_;
       }
     } else {
@@ skipping 40 matching lines @@
             parameters_.encoder_config.streams[i].target_bitrate_bps;
       }
     }
 
     if (stream_ == NULL)
       return info;
 
     stats = stream_->GetStats();
   }
   info.adapt_changes = number_of_cpu_adapt_changes_;
-  info.adapt_reason = cpu_restricted_counter_ <= 0
-                          ? CoordinatedVideoAdapter::ADAPTREASON_NONE
-                          : CoordinatedVideoAdapter::ADAPTREASON_CPU;
+  info.adapt_reason =
+      cpu_restricted_counter_ <= 0 ? ADAPTREASON_NONE : ADAPTREASON_CPU;
 
   if (capturer_) {
       VideoFormat last_captured_frame_format;
       capturer_->GetStats(&last_captured_frame_format);
       info.input_frame_width = last_captured_frame_format.width;
       info.input_frame_height = last_captured_frame_format.height;
   }
 
   // Get bandwidth limitation info from stream_->GetStats().
   // Input resolution (output from video_adapter) can be further scaled down or
   // higher video layer(s) can be dropped due to bitrate constraints.
   // Note, adapt_changes only include changes from the video_adapter.
   if (stats.bw_limited_resolution)
-    info.adapt_reason |= CoordinatedVideoAdapter::ADAPTREASON_BANDWIDTH;
+    info.adapt_reason |= ADAPTREASON_BANDWIDTH;
 
   info.encoder_implementation_name = stats.encoder_implementation_name;
   info.ssrc_groups = ssrc_groups_;
   info.framerate_input = stats.input_frame_rate;
   info.framerate_sent = stats.encode_frame_rate;
   info.avg_encode_ms = stats.avg_encode_time_ms;
   info.encode_usage_percent = stats.encode_usage_percent;
 
   info.nominal_bitrate = stats.media_bitrate_bps;
 
@@ skipping 478 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             fec_settings.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket