Add metadata to media::VideoFrame and plumb it through IPC/MediaStream.

content/browser/media/capture/content_video_capture_device_core.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 "content/browser/media/capture/content_video_capture_device_core.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_forward.h"
 #include "base/callback_helpers.h"
@@ skipping 52 matching lines @@
 }
 
 ThreadSafeCaptureOracle::~ThreadSafeCaptureOracle() {}
 
 bool ThreadSafeCaptureOracle::ObserveEventAndDecideCapture(
     VideoCaptureOracle::Event event,
     const gfx::Rect& damage_rect,
     base::TimeTicks event_time,
     scoped_refptr<media::VideoFrame>* storage,
     CaptureFrameCallback* callback) {
+  // Grab the current time before waiting to acquire the |lock_|.
+  const base::TimeTicks capture_begin_time = base::TimeTicks::Now();
+
   base::AutoLock guard(lock_);
 
   if (!client_)
     return false;  // Capture is stopped.
 
   // Always round up the coded size to multiple of 16 pixels.
   // See http://crbug.com/402151.
   const gfx::Size visible_size = params_.requested_format.frame_size;
   const gfx::Size coded_size((visible_size.width() + 15) & ~15,
                              (visible_size.height() + 15) & ~15);
@@ skipping 51 matching lines @@
         static_cast<uint8*>(output_buffer->data()),
         output_buffer->size(),
         base::SharedMemory::NULLHandle(),
         0,
         base::TimeDelta(),
         base::Closure());
   }
   *callback = base::Bind(&ThreadSafeCaptureOracle::DidCaptureFrame,
                          this,
                          frame_number,
-                         output_buffer);
+                         output_buffer,
+                         capture_begin_time);
   return true;
 }
 
 gfx::Size ThreadSafeCaptureOracle::GetCaptureSize() const {
   base::AutoLock guard(lock_);
   return params_.requested_format.frame_size;
 }
 
 void ThreadSafeCaptureOracle::UpdateCaptureSize(const gfx::Size& source_size) {
   base::AutoLock guard(lock_);
@@ skipping 26 matching lines @@
 
 void ThreadSafeCaptureOracle::ReportError(const std::string& reason) {
   base::AutoLock guard(lock_);
   if (client_)
     client_->OnError(reason);
 }
 
 void ThreadSafeCaptureOracle::DidCaptureFrame(
     int frame_number,
     const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer,
+    base::TimeTicks capture_begin_time,
     const scoped_refptr<media::VideoFrame>& frame,
     base::TimeTicks timestamp,
     bool success) {
   base::AutoLock guard(lock_);
   TRACE_EVENT_ASYNC_END2("mirroring", "Capture", buffer.get(),
                          "success", success,
                          "timestamp", timestamp.ToInternalValue());
 
   if (!client_)
     return;  // Capture is stopped.
 
   if (success) {
     if (oracle_->CompleteCapture(frame_number, &timestamp)) {
-      media::VideoCaptureFormat format = params_.requested_format;
-      // TODO(miu): Passing VideoCaptureFormat here introduces ambiguities.  The
-      // following is a hack where frame_size takes on a different meaning than
-      // everywhere else (i.e., coded size, not visible size).  Will fix in
-      // soon-upcoming code change.
-      format.frame_size = frame->coded_size();
-      client_->OnIncomingCapturedVideoFrame(buffer, format, frame, timestamp);
+      // TODO(miu): Use the locked-in frame rate from AnimatedContentSampler.
+      frame->metadata().SetDouble(media::VideoFrame::kFrameRateMetadataKey,
+                                  params_.requested_format.frame_rate);
+      // Provide capture begin/end timestamps in the VideoFrame metadata.
+      // Casting the int64 internal value of the start and end TimeTickses to
+      // double is reasonable here.  This will guarantee 1us resolution for
+      // values up to 2^53 (e.g., ~285 years since kernel boot).  Alternative
+      // approaches are much more heavyweight (e.g., storing the low and high 32
+      // bits as separate fields, storing as formatted ASCII strings, etc.).
+      frame->metadata().SetDouble(
+          "captureBeginTimeTicks",

[Alpha Left Google, 2015/02/26 21:17:23]

Can these names be defined in video_frame.h as well?

[miu, 2015/02/26 23:25:18]

I'm uncomfortable with starting the practice of putting all the possible
metadata keys in video_frame.h.  The captureBegin/End keys are very specific to
one producer (tab/desktop capture) combined with one consumer (Cast streaming). 
The other issue is where we might centrally locate the definition of the keys,
but there is really no good place (i.e., the tab capture code cannot DEPS on
media/cast and vice-versa).

+          static_cast<double>(capture_begin_time.ToInternalValue()));
+      frame->metadata().SetDouble(
+          "captureEndTimeTicks",
+          static_cast<double>(base::TimeTicks::Now().ToInternalValue()));
+      client_->OnIncomingCapturedVideoFrame(buffer, frame, timestamp);
     }
   }
 }
 
 void ContentVideoCaptureDeviceCore::AllocateAndStart(
     const media::VideoCaptureParams& params,
     scoped_ptr<media::VideoCaptureDevice::Client> client) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (state_ != kIdle) {
@@ skipping 129 matching lines @@
     return;
 
   if (oracle_proxy_.get())
     oracle_proxy_->ReportError(reason);
 
   StopAndDeAllocate();
   TransitionStateTo(kError);
 }
 
 }  // namespace content