Add histogram for percentage of incoming frames that are limited in resolution due to cpu

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 13 matching lines @@
 #include "webrtc/media/engine/constants.h"
 #include "webrtc/media/engine/simulcast.h"
 #include "webrtc/media/engine/webrtcmediaengine.h"
 #include "webrtc/media/engine/webrtcvideoencoderfactory.h"
 #include "webrtc/media/engine/webrtcvideoframe.h"
 #include "webrtc/media/engine/webrtcvoiceengine.h"
 #include "webrtc/modules/video_coding/codecs/h264/include/h264.h"
 #include "webrtc/modules/video_coding/codecs/vp8/simulcast_encoder_adapter.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/system_wrappers/include/field_trial.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 #include "webrtc/video_decoder.h"
 #include "webrtc/video_encoder.h"
 
 namespace cricket {
 namespace {
 
 // Wrap cricket::WebRtcVideoEncoderFactory as a webrtc::VideoEncoderFactory.
 class EncoderFactoryAdapter : public webrtc::VideoEncoderFactory {
  public:
   // EncoderFactoryAdapter doesn't take ownership of |factory|, which is owned
@@ skipping 1525 matching lines @@
     const rtc::Optional<std::vector<webrtc::RtpExtension>>& rtp_extensions,
     // TODO(deadbeef): Don't duplicate information between send_params,
     // rtp_extensions, options, etc.
     const VideoSendParameters& send_params)
     : worker_thread_(rtc::Thread::Current()),
       ssrcs_(sp.ssrcs),
       ssrc_groups_(sp.ssrc_groups),
       call_(call),
       cpu_restricted_counter_(0),
       number_of_cpu_adapt_changes_(0),
+      frames_(0),
+      cpu_restricted_frames_(0),
       source_(nullptr),
       external_encoder_factory_(external_encoder_factory),
       stream_(nullptr),
       parameters_(config, options, max_bitrate_bps, codec_settings),
       rtp_parameters_(CreateRtpParametersWithOneEncoding()),
       pending_encoder_reconfiguration_(false),
       allocated_encoder_(nullptr, webrtc::kVideoCodecUnknown, false),
       sending_(false),
       last_frame_timestamp_ms_(0) {
   parameters_.config.rtp.max_packet_size = kVideoMtu;
@@ skipping 25 matching lines @@
     SetCodec(*codec_settings);
   }
 }
 
 WebRtcVideoChannel2::WebRtcVideoSendStream::~WebRtcVideoSendStream() {
   DisconnectSource();
   if (stream_ != NULL) {
     call_->DestroyVideoSendStream(stream_);
   }
   DestroyVideoEncoder(&allocated_encoder_);
+  UpdateHistograms();
+}
+
+void WebRtcVideoChannel2::WebRtcVideoSendStream::UpdateHistograms() const {
+  const int kMinRequiredFrames = 200;
+  if (frames_ > kMinRequiredFrames) {
+    RTC_LOGGED_HISTOGRAM_PERCENTAGE(
+        "WebRTC.Video.CpuLimitedResolutionInPercent",
+        cpu_restricted_frames_ * 100 / frames_);

[perkj_webrtc, 2016/08/22 09:06:42]

suggest rename frames_ to frame_count_. Suggest to change cpu_restricted_frames
to cpu_restricted_frame_count_

[åsapersson, 2016/08/22 09:41:51]

Done.

+  }
 }
 
 void WebRtcVideoChannel2::WebRtcVideoSendStream::OnFrame(
     const VideoFrame& frame) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::OnFrame");
   webrtc::VideoFrame video_frame(frame.video_frame_buffer(), 0, 0,
                                  frame.rotation());
   rtc::CritScope cs(&lock_);
 
   if (video_frame.width() != last_frame_info_.width ||
@@ skipping 34 matching lines @@
     pending_encoder_reconfiguration_ = false;
   }
 
   // Not sending, abort after reconfiguration. Reconfiguration should still
   // occur to permit sending this input as quickly as possible once we start
   // sending (without having to reconfigure then).
   if (!sending_) {
     return;
   }
 
+  ++frames_;

[perkj_webrtc, 2016/08/22 09:06:42]

frames_ and cpu_restricted_frames_ will be written by the camera thread and and
read by the worker thread in thi s cl.
Easiest way that is consistent with the rest in this file is probably just to
declare frames_  cpu_restricted_frames_ as GUARDED_BY(&lock_) and take lock in
UpdateHistograms if that is safe.  

[åsapersson, 2016/08/22 09:41:51]

Added guarded_by (and exclusive_lock_required for UpdateHistograms since called
from destructor).

+  if (cpu_restricted_counter_ > 0)

[perkj_webrtc, 2016/08/19 13:14:46]

Would it be possible to do this in ViEEncoder instead? I am trying to remove all
dependencies to frames from this class and express CPU adaptation in ViEEncoder
as VideoSinkWants.

[åsapersson, 2016/08/22 07:56:29]

Could it be done in a separate/follow up CL when the cpu adaptation is expressed
in ViEEncoder?

[perkj_webrtc, 2016/08/22 09:06:42]

sure.

+    ++cpu_restricted_frames_;
+
   stream_->Input()->IncomingCapturedFrame(video_frame);
 }
 
 bool WebRtcVideoChannel2::WebRtcVideoSendStream::SetVideoSend(
     bool enable,
     const VideoOptions* options,
     rtc::VideoSourceInterface<cricket::VideoFrame>* source) {
   TRACE_EVENT0("webrtc", "WebRtcVideoSendStream::SetVideoSend");
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 1008 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