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

content/browser/renderer_host/media/video_capture_controller.cc

 // Copyright (c) 2012 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/renderer_host/media/video_capture_controller.h"
 
 #include <map>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 157 matching lines @@
   // VideoCaptureDevice::Client implementation.
   void OnIncomingCapturedData(const uint8* data,
                               int length,
                               const VideoCaptureFormat& frame_format,
                               int rotation,
                               const base::TimeTicks& timestamp) override;
   scoped_refptr<Buffer> ReserveOutputBuffer(media::VideoFrame::Format format,
                                             const gfx::Size& size) override;
   void OnIncomingCapturedVideoFrame(
       const scoped_refptr<Buffer>& buffer,
-      const VideoCaptureFormat& buffer_format,
       const scoped_refptr<media::VideoFrame>& frame,
       const base::TimeTicks& timestamp) override;
   void OnError(const std::string& reason) override;
   void OnLog(const std::string& message) override;
 
  private:
   // The controller to which we post events.
   const base::WeakPtr<VideoCaptureController> controller_;
 
   // The pool of shared-memory buffers used for capturing.
@@ skipping 351 matching lines @@
           gfx::Rect(dimensions),
           dimensions,
           yplane,
           media::VideoFrame::AllocationSize(media::VideoFrame::I420,
                                             dimensions),
           base::SharedMemory::NULLHandle(),
           0,
           base::TimeDelta(),
           base::Closure());
   DCHECK(frame.get());
+  frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                               frame_format.frame_rate);
 
-  VideoCaptureFormat format(
-      dimensions, frame_format.frame_rate, media::PIXEL_FORMAT_I420);
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
           controller_,
           buffer,
-          format,
           frame,
           timestamp));
 }
 
 void
 VideoCaptureController::VideoCaptureDeviceClient::OnIncomingCapturedVideoFrame(
     const scoped_refptr<Buffer>& buffer,
-    const VideoCaptureFormat& buffer_format,
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& timestamp) {
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(
           &VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread,
           controller_,
           buffer,
-          buffer_format,
           frame,
           timestamp));
 }
 
 void VideoCaptureController::VideoCaptureDeviceClient::OnError(
     const std::string& reason) {
   const std::string log_message = base::StringPrintf(
       "Error on video capture: %s, OS message: %s",
       reason.c_str(),
       logging::SystemErrorCodeToString(
@@ skipping 10 matching lines @@
   MediaStreamManager::SendMessageToNativeLog("Video capture: " + message);
 }
 
 VideoCaptureController::~VideoCaptureController() {
   STLDeleteContainerPointers(controller_clients_.begin(),
                              controller_clients_.end());
 }
 
 void VideoCaptureController::DoIncomingCapturedVideoFrameOnIOThread(
     const scoped_refptr<media::VideoCaptureDevice::Client::Buffer>& buffer,
-    const media::VideoCaptureFormat& buffer_format,
     const scoped_refptr<media::VideoFrame>& frame,
     const base::TimeTicks& timestamp) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_NE(buffer->id(), VideoCaptureBufferPool::kInvalidId);
 
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
+    if (!frame->metadata()->HasKey(media::VideoFrameMetadata::FRAME_RATE)) {
+      frame->metadata()->SetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                                   video_capture_format_.frame_rate);
+    }
+    scoped_ptr<base::DictionaryValue> metadata(new base::DictionaryValue());
+    frame->metadata()->MergeInternalValuesInto(metadata.get());
+
     for (const auto& client : controller_clients_) {
       if (client->session_closed || client->paused)
         continue;
 
+      scoped_ptr<base::DictionaryValue> copy_of_metadata;
+      if (client == controller_clients_.back())
+        copy_of_metadata = metadata.Pass();
+      else
+        copy_of_metadata.reset(metadata->DeepCopy());
+
       if (frame->format() == media::VideoFrame::NATIVE_TEXTURE) {
+        DCHECK(frame->coded_size() == frame->visible_rect().size())
+            << "Textures are always supposed to be tightly packed.";
         client->event_handler->OnMailboxBufferReady(client->controller_id,
                                                     buffer->id(),
                                                     *frame->mailbox_holder(),
-                                                    buffer_format,
-                                                    timestamp);
-      } else {
+                                                    frame->coded_size(),
+                                                    timestamp,
+                                                    copy_of_metadata.Pass());
+      } else if (frame->format() == media::VideoFrame::I420) {
         bool is_new_buffer = client->known_buffers.insert(buffer->id()).second;
         if (is_new_buffer) {
           // On the first use of a buffer on a client, share the memory handle.
           size_t memory_size = 0;
           base::SharedMemoryHandle remote_handle = buffer_pool_->ShareToProcess(
               buffer->id(), client->render_process_handle, &memory_size);
           client->event_handler->OnBufferCreated(
               client->controller_id, remote_handle, memory_size, buffer->id());
         }
 
         client->event_handler->OnBufferReady(
-            client->controller_id, buffer->id(), buffer_format,
-            frame->visible_rect(), timestamp);
+            client->controller_id, buffer->id(), frame->coded_size(),
+            frame->visible_rect(), timestamp, copy_of_metadata.Pass());
+      } else {
+        // VideoFrame format not supported.
+        NOTREACHED();
+        break;
       }
 
       bool inserted =
           client->active_buffers.insert(std::make_pair(buffer->id(), frame))
               .second;
       DCHECK(inserted) << "Unexpected duplicate buffer: " << buffer->id();
       count++;
     }
   }
 
   if (!has_received_frames_) {
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.Width",
-                         buffer_format.frame_size.width());
+                         frame->visible_rect().width());
     UMA_HISTOGRAM_COUNTS("Media.VideoCapture.Height",
-                         buffer_format.frame_size.height());
+                         frame->visible_rect().height());
     UMA_HISTOGRAM_ASPECT_RATIO("Media.VideoCapture.AspectRatio",
-                               buffer_format.frame_size.width(),
-                               buffer_format.frame_size.height());
-    UMA_HISTOGRAM_COUNTS("Media.VideoCapture.FrameRate",
-                         buffer_format.frame_rate);
+                               frame->visible_rect().width(),
+                               frame->visible_rect().height());
+    double frame_rate;
+    if (!frame->metadata()->GetDouble(media::VideoFrameMetadata::FRAME_RATE,
+                                      &frame_rate))
+      frame_rate = video_capture_format_.frame_rate;
+    UMA_HISTOGRAM_COUNTS("Media.VideoCapture.FrameRate", frame_rate);
     has_received_frames_ = true;
   }
 
   buffer_pool_->HoldForConsumers(buffer->id(), count);
 }
 
 void VideoCaptureController::DoErrorOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   state_ = VIDEO_CAPTURE_STATE_ERROR;
 
@@ skipping 61 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int active_client_count = 0;
   for (ControllerClient* client : controller_clients_) {
     if (!client->paused)
       ++active_client_count;
   }
   return active_client_count;
 }
 
 }  // namespace content