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"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_frame.h"
+#include "media/base/video_frame_metadata.h"
 #include "media/base/video_util.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace content {
 
 namespace {
 
 void DeleteCaptureMachineOnUIThread(
     scoped_ptr<VideoCaptureMachine> capture_machine) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 26 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::VideoFrameMetadata::FRAME_RATE,
+                                   params_.requested_format.frame_rate);
+      frame->metadata()->SetTimeTicks(
+          media::VideoFrameMetadata::CAPTURE_BEGIN_TIME, capture_begin_time);
+      frame->metadata()->SetTimeTicks(
+          media::VideoFrameMetadata::CAPTURE_END_TIME, base::TimeTicks::Now());
+      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 122 matching lines @@
     return;
 
   if (oracle_proxy_.get())
     oracle_proxy_->ReportError(reason);
 
   StopAndDeAllocate();
   TransitionStateTo(kError);
 }
 
 }  // namespace content