HW Video: Make media::VideoFrame handle the sync point of the compositor as well as webgl

content/renderer/media/video_capture_impl.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/renderer/media/video_capture_impl.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/child/child_process.h"
 #include "content/common/media/video_capture_messages.h"
@@ skipping 236 matching lines @@
 
 void VideoCaptureImpl::OnBufferReceived(int buffer_id,
                                         const media::VideoCaptureFormat& format,
                                         base::TimeTicks timestamp) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // The capture pipeline supports only I420 for now.
   DCHECK_EQ(format.pixel_format, media::PIXEL_FORMAT_I420);
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
-    Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
+    Send(new VideoCaptureHostMsg_BufferReady(
+        device_id_, buffer_id, std::vector<uint32>()));
     return;
   }
 
   last_frame_format_ = format;
   if (first_frame_timestamp_.is_null())
     first_frame_timestamp_ = timestamp;
 
   ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
   DCHECK(iter != client_buffers_.end());
   scoped_refptr<ClientBuffer> buffer = iter->second;
   scoped_refptr<media::VideoFrame> frame =
       media::VideoFrame::WrapExternalPackedMemory(
           media::VideoFrame::I420,
           last_frame_format_.frame_size,
           gfx::Rect(last_frame_format_.frame_size),
           last_frame_format_.frame_size,
           reinterpret_cast<uint8*>(buffer->buffer->memory()),
           buffer->buffer_size,
           buffer->buffer->handle(),
           timestamp - first_frame_timestamp_,
-          media::BindToCurrentLoop(base::Bind(
-              &VideoCaptureImpl::OnClientBufferFinished,
-              weak_this_factory_.GetWeakPtr(),
-              buffer_id,
-              buffer,
-              base::Passed(scoped_ptr<gpu::MailboxHolder>().Pass()))));
+          media::BindToCurrentLoop(
+              base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
+                         weak_this_factory_.GetWeakPtr(),
+                         buffer_id,
+                         buffer,
+                         base::Passed(scoped_ptr<gpu::MailboxHolder>().Pass()),
+                         std::vector<uint32>())));
 
   for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it)
     it->first->OnFrameReady(this, frame);
 }
 
-static void NullReadPixelsCB(const SkBitmap& bitmap) { NOTIMPLEMENTED(); }
+// TODO(dshwang): implement it.
+static void NullReadPixelsCB(const scoped_refptr<media::VideoFrame>&,
+                             const SkBitmap& bitmap) {
+  NOTIMPLEMENTED();

[dshwang, 2014/03/10 17:38:08]

Now GpuVideoAcceleratorFactories::ReadPixels() receive VideoFrame, instead of
texture. So I'll implement it in next CL.

After that, software 2d canvas can draws video based on VideoSource which is HW
accelerated.

+}
 
 void VideoCaptureImpl::OnMailboxBufferReceived(
     int buffer_id,
     const gpu::MailboxHolder& mailbox_holder,
     const media::VideoCaptureFormat& format,
     base::TimeTicks timestamp) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
     Send(new VideoCaptureHostMsg_BufferReady(
-        device_id_, buffer_id, mailbox_holder.sync_point));
+        device_id_, buffer_id, std::vector<uint32>()));
     return;
   }
 
   last_frame_format_ = format;
   if (first_frame_timestamp_.is_null())
     first_frame_timestamp_ = timestamp;
 
   scoped_refptr<media::VideoFrame> frame = media::VideoFrame::WrapNativeTexture(
       make_scoped_ptr(new gpu::MailboxHolder(mailbox_holder)),
       media::BindToCurrentLoop(
           base::Bind(&VideoCaptureImpl::OnClientBufferFinished,
                      weak_this_factory_.GetWeakPtr(),
                      buffer_id,
                      scoped_refptr<ClientBuffer>())),
       last_frame_format_.frame_size,
       gfx::Rect(last_frame_format_.frame_size),
       last_frame_format_.frame_size,
       timestamp - first_frame_timestamp_,
       base::Bind(&NullReadPixelsCB));
 
   for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it)
     it->first->OnFrameReady(this, frame);
 }
 
 void VideoCaptureImpl::OnClientBufferFinished(
     int buffer_id,
     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
-    scoped_ptr<gpu::MailboxHolder> mailbox_holder) {
+    scoped_ptr<gpu::MailboxHolder> mailbox_holder,
+    const std::vector<uint32>& release_sync_points) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
-  const uint32 sync_point = (mailbox_holder ? mailbox_holder->sync_point : 0);
-  Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, sync_point));
+  Send(new VideoCaptureHostMsg_BufferReady(
+      device_id_, buffer_id, release_sync_points));
 }
 
 void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
   DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   switch (state) {
     case VIDEO_CAPTURE_STATE_STARTED:
       break;
     case VIDEO_CAPTURE_STATE_STOPPED:
       state_ = VIDEO_CAPTURE_STATE_STOPPED;
@@ skipping 122 matching lines @@
   if (it != clients->end()) {
     handler->OnStopped(this);
     handler->OnRemoved(this);
     clients->erase(it);
     found = true;
   }
   return found;
 }
 
 }  // namespace content