[Cast] Compute utilization metrics and add performance overlay.

media/cast/sender/vp8_encoder.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/cast/sender/vp8_encoder.h"
 
 #include "base/logging.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_defines.h"
-#include "media/cast/net/cast_transport_config.h"
 #include "third_party/libvpx/source/libvpx/vpx/vp8cx.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // After a pause in the video stream, what is the maximum duration amount to
 // pass to the encoder for the next frame (in terms of 1/max_fps sized periods)?
 // This essentially controls the encoded size of the first frame that follows a
@@ skipping 136 matching lines @@
   // Improve quality by enabling sets of codec features that utilize more CPU.
   // The default is zero, with increasingly more CPU to be used as the value is
   // more negative.
   // TODO(miu): Document why this value was chosen and expected behaviors.
   // Should this be dynamic w.r.t. hardware performance?
   CHECK_EQ(vpx_codec_control(&encoder_, VP8E_SET_CPUUSED, -6), VPX_CODEC_OK);
 }
 
 void Vp8Encoder::Encode(const scoped_refptr<media::VideoFrame>& video_frame,
                         const base::TimeTicks& reference_time,
-                        EncodedFrame* encoded_frame) {
+                        SenderEncodedFrame* encoded_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(encoded_frame);
 
+  // Note: This is used to compute the |deadline_utilization| and so it uses the
+  // real-world clock instead of the CastEnvironment clock, the latter of which
+  // might be simulated.
+  const base::TimeTicks start_time = base::TimeTicks::Now();
+
   // Initialize on-demand.  Later, if the video frame size has changed, update
   // the encoder configuration.
   const gfx::Size frame_size = video_frame->visible_rect().size();
   if (!is_initialized() || gfx::Size(config_.g_w, config_.g_h) != frame_size)
     ConfigureForNewFrameSize(frame_size);
 
   uint32 latest_frame_id_to_reference;
   Vp8Buffers buffer_to_update;
   vpx_codec_flags_t flags = 0;
   if (key_frame_requested_) {
@@ skipping 91 matching lines @@
         TimeDeltaToRtpDelta(video_frame->timestamp(), kVideoFrequency);
     encoded_frame->reference_time = reference_time;
     encoded_frame->data.assign(
         static_cast<const uint8*>(pkt->data.frame.buf),
         static_cast<const uint8*>(pkt->data.frame.buf) + pkt->data.frame.sz);
     break;  // Done, since all data is provided in one CX_FRAME_PKT packet.
   }
   DCHECK(!encoded_frame->data.empty())
       << "BUG: Encoder must provide data since lagged encoding is disabled.";
 
+  // Compute deadline utilization as the real-world time elapsed divided by the
+  // frame duration.
+  const base::TimeDelta processing_time = base::TimeTicks::Now() - start_time;
+  encoded_frame->deadline_utilization =
+      processing_time.InSecondsF() / predicted_frame_duration.InSecondsF();
+
+  // Compute lossy utilization.  The VP8 encoder took an estimated guess at what
+  // quantizer value would produce an encoded frame size as close to the target
+  // as possible.  Now that the frame has been encoded and the number of bytes
+  // is known, the perfect quantizer value (i.e., the one that should have been
+  // used) can be determined.  This perfect quantizer is then normalized and
+  // used as the lossy utilization.
+  const double actual_bitrate =
+      encoded_frame->data.size() * 8.0 / predicted_frame_duration.InSecondsF();
+  const double target_bitrate = 1000.0 * config_.rc_target_bitrate;
+  DCHECK_GT(target_bitrate, 0.0);
+  const double bitrate_utilization = actual_bitrate / target_bitrate;
+  int quantizer = -1;
+  CHECK_EQ(vpx_codec_control(&encoder_, VP8E_GET_LAST_QUANTIZER_64, &quantizer),
+           VPX_CODEC_OK);
+  const double perfect_quantizer = bitrate_utilization * std::max(0, quantizer);
+  // Side note: If it was possible for the encoder to encode within the target
+  // number of bytes, the |perfect_quantizer| will be in the range [0.0,63.0].
+  // If it was never possible, the value will be greater than 63.0.
+  encoded_frame->lossy_utilization = perfect_quantizer / 63.0;
+
   DVLOG(2) << "VP8 encoded frame_id " << encoded_frame->frame_id
-           << ", sized:" << encoded_frame->data.size();
+           << ", sized: " << encoded_frame->data.size()
+           << ", deadline_utilization: " << encoded_frame->deadline_utilization
+           << ", lossy_utilization: " << encoded_frame->lossy_utilization
+           << " (quantizer chosen by the encoder was " << quantizer << ')';
 
   if (encoded_frame->dependency == EncodedFrame::KEY) {
     key_frame_requested_ = false;
 
     for (int i = 0; i < kNumberOfVp8VideoBuffers; ++i) {
       buffer_state_[i].state = kBufferSent;
       buffer_state_[i].frame_id = encoded_frame->frame_id;
     }
   } else {
     if (buffer_to_update != kNoBuffer) {
@@ skipping 182 matching lines @@
   }
 }
 
 void Vp8Encoder::GenerateKeyFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_requested_ = true;
 }
 
 }  // namespace cast
 }  // namespace media