New FRAME_DURATION VideoFrameMetadata, with Cast Streaming use case.

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"
@@ skipping 197 matching lines @@
       video_frame->visible_data(VideoFrame::kUPlane);
   vpx_image.planes[VPX_PLANE_V] =
       video_frame->visible_data(VideoFrame::kVPlane);
   vpx_image.stride[VPX_PLANE_Y] = video_frame->stride(VideoFrame::kYPlane);
   vpx_image.stride[VPX_PLANE_U] = video_frame->stride(VideoFrame::kUPlane);
   vpx_image.stride[VPX_PLANE_V] = video_frame->stride(VideoFrame::kVPlane);
 
   // The frame duration given to the VP8 codec affects a number of important
   // behaviors, including: per-frame bandwidth, CPU time spent encoding,
   // temporal quality trade-offs, and key/golden/alt-ref frame generation
-  // intervals.  Use the actual amount of time between the current and previous
-  // frames as a prediction for the next frame's duration, but bound the
-  // prediction to account for the fact that the frame rate can be highly
-  // variable, including long pauses in the video stream.
+  // intervals.  Bound the prediction to account for the fact that the frame
+  // rate can be highly variable, including long pauses in the video stream.
   const base::TimeDelta minimum_frame_duration =
       base::TimeDelta::FromSecondsD(1.0 / cast_config_.max_frame_rate);
   const base::TimeDelta maximum_frame_duration =
       base::TimeDelta::FromSecondsD(static_cast<double>(kRestartFramePeriods) /
                                         cast_config_.max_frame_rate);
-  const base::TimeDelta last_frame_duration =
-      video_frame->timestamp() - last_frame_timestamp_;
-  const base::TimeDelta predicted_frame_duration =
+  base::TimeDelta predicted_frame_duration;
+  if (!video_frame->metadata()->GetTimeDelta(
+          media::VideoFrameMetadata::FRAME_DURATION,
+          &predicted_frame_duration) ||
+      predicted_frame_duration <= base::TimeDelta()) {
+    // The source of the video frame did not provide the frame duration.  Use
+    // the actual amount of time between the current and previous frame as a
+    // prediction for the next frame's duration.
+    predicted_frame_duration = video_frame->timestamp() - last_frame_timestamp_;
+  }
+  predicted_frame_duration =
       std::max(minimum_frame_duration,
-               std::min(maximum_frame_duration, last_frame_duration));
+               std::min(maximum_frame_duration, predicted_frame_duration));
   last_frame_timestamp_ = video_frame->timestamp();
 
   // Encode the frame.  The presentation time stamp argument here is fixed to
   // zero to force the encoder to base its single-frame bandwidth calculations
   // entirely on |predicted_frame_duration| and the target bitrate setting being
   // micro-managed via calls to UpdateRates().
   CHECK_EQ(vpx_codec_encode(&encoder_,
                             &vpx_image,
                             0,
                             predicted_frame_duration.InMicroseconds(),
@@ skipping 228 matching lines @@
   }
 }
 
 void Vp8Encoder::GenerateKeyFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   key_frame_requested_ = true;
 }
 
 }  // namespace cast
 }  // namespace media