RESOURCE_UTILIZATION in VideoFrameMetadata, a consumer feedback signal.

media/cast/sender/video_sender.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/video_sender.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/trace_event/trace_event.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/sender/performance_metrics_overlay.h"
 #include "media/cast/sender/video_encoder.h"
 
 namespace media {
 namespace cast {
 
 namespace {
 
 // The following two constants are used to adjust the target
 // playout delay (when allowed). They were calculated using
 // a combination of cast_benchmark runs and manual testing.
 //
 // This is how many round trips we think we need on the network.
 const int kRoundTripsNeeded = 4;
+
 // This is an estimate of all the the constant time needed independent of
 // network quality (e.g., additional time that accounts for encode and decode
 // time).
 const int kConstantTimeMs = 75;
 
+// The target maximum utilization of the encoder and network resources.  This is
+// used to attenuate the actual measured utilization values in order to provide
+// "breathing room" (i.e., to ensure there will be sufficient CPU and bandwidth
+// available to handle the occasional more-complex frames).
+const int kTargetUtilizationPercentage = 75;
+
 // Extract capture begin/end timestamps from |video_frame|'s metadata and log
 // it.
 void LogVideoCaptureTimestamps(const CastEnvironment& cast_environment,
                                const media::VideoFrame& video_frame,
                                RtpTimestamp rtp_timestamp) {
   base::TimeTicks capture_begin_time;
   base::TimeTicks capture_end_time;
   if (!video_frame.metadata()->GetTimeTicks(
           media::VideoFrameMetadata::CAPTURE_BEGIN_TIME, &capture_begin_time) ||
       !video_frame.metadata()->GetTimeTicks(
@@ skipping 157 matching lines @@
                                        frames_in_encoder_ + 1,
                                        last_reported_deadline_utilization_,
                                        last_reported_lossy_utilization_,
                                        video_frame.get());
 
   if (video_encoder_->EncodeVideoFrame(
           video_frame,
           reference_time,
           base::Bind(&VideoSender::OnEncodedVideoFrame,
                      weak_factory_.GetWeakPtr(),
+                     video_frame,
                      bitrate))) {
     frames_in_encoder_++;
     duration_in_encoder_ += duration_added_by_next_frame;
     last_enqueued_frame_rtp_timestamp_ = rtp_timestamp;
     last_enqueued_frame_reference_time_ = reference_time;
   } else {
     VLOG(1) << "Encoder rejected a frame.  Skipping...";
   }
 }
 
@@ skipping 13 matching lines @@
   } else {
     return duration_in_encoder_;
   }
 }
 
 void VideoSender::OnAck(uint32 frame_id) {
   video_encoder_->LatestFrameIdToReference(frame_id);
 }
 
 void VideoSender::OnEncodedVideoFrame(
+    const scoped_refptr<media::VideoFrame>& video_frame,
     int encoder_bitrate,
     scoped_ptr<SenderEncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   frames_in_encoder_--;
   DCHECK_GE(frames_in_encoder_, 0);
 
   duration_in_encoder_ =
       last_enqueued_frame_reference_time_ - encoded_frame->reference_time;
 
   last_reported_deadline_utilization_ = encoded_frame->deadline_utilization;
   last_reported_lossy_utilization_ = encoded_frame->lossy_utilization;
-  // TODO(miu): Plumb-in a utilization feedback signal back to the producer of
-  // the video frames.  http://crbug.com/156767
+
+  // Report the resource utilization for processing this frame.  Take the
+  // greater of the two utilization values and attenuate them such that the
+  // target utilization is reported as the maximum sustainable amount.
+  const double attenuated_utilization =
+      std::max(last_reported_deadline_utilization_,
+               last_reported_lossy_utilization_) /
+          (kTargetUtilizationPercentage / 100.0);
+  if (attenuated_utilization >= 0.0) {
+    // Key frames are artificially capped to 1.0 because their actual
+    // utilization is atypical compared to the other frames in the stream, and
+    // this can misguide the producer of the input video frames.
+    video_frame->metadata()->SetDouble(
+        media::VideoFrameMetadata::RESOURCE_UTILIZATION,
+        encoded_frame->dependency == EncodedFrame::KEY ?
+            std::min(1.0, attenuated_utilization) : attenuated_utilization);
+  }
 
   SendEncodedFrame(encoder_bitrate, encoded_frame.Pass());
 }
 
 }  // namespace cast
 }  // namespace media