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

media/base/video_frame.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 "media/base/video_frame.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
@@ skipping 32 matching lines @@
       new_coded_size.set_height((new_coded_size.height() + 1) / 2 * 2);
     // Fallthrough.
     case VideoFrame::YV16:
       new_coded_size.set_width((new_coded_size.width() + 1) / 2 * 2);
       break;
     default:
       LOG(FATAL) << "Only YUV formats supported: " << format;
       return NULL;
   }
   DCHECK(IsValidConfig(format, new_coded_size, visible_rect, natural_size));
-  scoped_refptr<VideoFrame> frame(new VideoFrame(
-      format, new_coded_size, visible_rect, natural_size, timestamp, false));
+  scoped_refptr<VideoFrame> frame(
+      new VideoFrame(format,
+                     new_coded_size,
+                     visible_rect,
+                     natural_size,
+                     scoped_ptr<gpu::MailboxHolder>(),
+                     timestamp,
+                     false));
   frame->AllocateYUV();
   return frame;
 }
 
 // static
 std::string VideoFrame::FormatToString(VideoFrame::Format format) {
   switch (format) {
     case VideoFrame::UNKNOWN:
       return "UNKNOWN";
     case VideoFrame::YV12:
@@ skipping 73 matching lines @@
     const ReleaseMailboxCB& mailbox_holder_release_cb,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp,
     const ReadPixelsCB& read_pixels_cb) {
   scoped_refptr<VideoFrame> frame(new VideoFrame(NATIVE_TEXTURE,
                                                  coded_size,
                                                  visible_rect,
                                                  natural_size,
+                                                 mailbox_holder.Pass(),
                                                  timestamp,
                                                  false));
-  frame->mailbox_holder_ = mailbox_holder.Pass();
   frame->mailbox_holder_release_cb_ = mailbox_holder_release_cb;
   frame->read_pixels_cb_ = read_pixels_cb;
 
   return frame;
 }
 
 void VideoFrame::ReadPixelsFromNativeTexture(const SkBitmap& pixels) {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
   if (!read_pixels_cb_.is_null())
     read_pixels_cb_.Run(pixels);
@@ skipping 10 matching lines @@
     base::SharedMemoryHandle handle,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
   if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
     return NULL;
   if (data_size < AllocationSize(format, coded_size))
     return NULL;
 
   switch (format) {
     case I420: {
-      scoped_refptr<VideoFrame> frame(new VideoFrame(
-          format, coded_size, visible_rect, natural_size, timestamp, false));
+      scoped_refptr<VideoFrame> frame(
+          new VideoFrame(format,
+                         coded_size,
+                         visible_rect,
+                         natural_size,
+                         scoped_ptr<gpu::MailboxHolder>(),
+                         timestamp,
+                         false));
       frame->shared_memory_handle_ = handle;
       frame->strides_[kYPlane] = coded_size.width();
       frame->strides_[kUPlane] = coded_size.width() / 2;
       frame->strides_[kVPlane] = coded_size.width() / 2;
       frame->data_[kYPlane] = data;
       frame->data_[kUPlane] = data + coded_size.GetArea();
       frame->data_[kVPlane] = data + (coded_size.GetArea() * 5 / 4);
       frame->no_longer_needed_cb_ = no_longer_needed_cb;
       return frame;
     }
@@ skipping 13 matching lines @@
     int32 u_stride,
     int32 v_stride,
     uint8* y_data,
     uint8* u_data,
     uint8* v_data,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
   if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
     return NULL;
 
-  scoped_refptr<VideoFrame> frame(new VideoFrame(
-      format, coded_size, visible_rect, natural_size, timestamp, false));
+  scoped_refptr<VideoFrame> frame(
+      new VideoFrame(format,
+                     coded_size,
+                     visible_rect,
+                     natural_size,
+                     scoped_ptr<gpu::MailboxHolder>(),
+                     timestamp,
+                     false));
   frame->strides_[kYPlane] = y_stride;
   frame->strides_[kUPlane] = u_stride;
   frame->strides_[kVPlane] = v_stride;
   frame->data_[kYPlane] = y_data;
   frame->data_[kUPlane] = u_data;
   frame->data_[kVPlane] = v_data;
   frame->no_longer_needed_cb_ = no_longer_needed_cb;
   return frame;
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapVideoFrame(
       const scoped_refptr<VideoFrame>& frame,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
       const base::Closure& no_longer_needed_cb) {
   // NATIVE_TEXTURE frames need mailbox info propagated, and there's no support
   // for that here yet, see http://crbug/362521.
   CHECK(frame->format() != NATIVE_TEXTURE);
 
   DCHECK(frame->visible_rect().Contains(visible_rect));
-  scoped_refptr<VideoFrame> wrapped_frame(new VideoFrame(
-      frame->format(), frame->coded_size(), visible_rect, natural_size,
-      frame->timestamp(), frame->end_of_stream()));
+  scoped_refptr<VideoFrame> wrapped_frame(
+      new VideoFrame(frame->format(),
+                     frame->coded_size(),
+                     visible_rect,
+                     natural_size,
+                     scoped_ptr<gpu::MailboxHolder>(),
+                     frame->timestamp(),
+                     frame->end_of_stream()));
 
   for (size_t i = 0; i < NumPlanes(frame->format()); ++i) {
     wrapped_frame->strides_[i] = frame->stride(i);
     wrapped_frame->data_[i] = frame->data(i);
   }
 
   wrapped_frame->no_longer_needed_cb_ = no_longer_needed_cb;
   return wrapped_frame;
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateEOSFrame() {
   return new VideoFrame(VideoFrame::UNKNOWN,
                         gfx::Size(),
                         gfx::Rect(),
                         gfx::Size(),
+                        scoped_ptr<gpu::MailboxHolder>(),
                         kNoTimestamp(),
                         true);
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateColorFrame(
     const gfx::Size& size,
     uint8 y, uint8 u, uint8 v,
     base::TimeDelta timestamp) {
   scoped_refptr<VideoFrame> frame = VideoFrame::CreateFrame(
@@ skipping 15 matching lines @@
 // maintained by the general compositor team. Please contact the following
 // people instead:
 //
 // wonsik@chromium.org
 // ycheo@chromium.org
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::CreateHoleFrame(
     const gfx::Size& size) {
   DCHECK(IsValidConfig(VideoFrame::HOLE, size, gfx::Rect(size), size));
-  scoped_refptr<VideoFrame> frame(new VideoFrame(
-      VideoFrame::HOLE, size, gfx::Rect(size), size, base::TimeDelta(), false));
+  scoped_refptr<VideoFrame> frame(
+      new VideoFrame(VideoFrame::HOLE,
+                     size,
+                     gfx::Rect(size),
+                     size,
+                     scoped_ptr<gpu::MailboxHolder>(),
+                     base::TimeDelta(),
+                     false));
   return frame;
 }
 #endif  // defined(VIDEO_HOLE)
 
 // static
 size_t VideoFrame::NumPlanes(Format format) {
   switch (format) {
     case VideoFrame::NATIVE_TEXTURE:
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
@@ skipping 141 matching lines @@
   if (format_ == YV12A) {
     data_[VideoFrame::kAPlane] = data + y_bytes + (2 * uv_bytes);
     strides_[VideoFrame::kAPlane] = y_stride;
   }
 }
 
 VideoFrame::VideoFrame(VideoFrame::Format format,
                        const gfx::Size& coded_size,
                        const gfx::Rect& visible_rect,
                        const gfx::Size& natural_size,
+                       scoped_ptr<gpu::MailboxHolder> mailbox_holder,
                        base::TimeDelta timestamp,
                        bool end_of_stream)
     : format_(format),
       coded_size_(coded_size),
       visible_rect_(visible_rect),
       natural_size_(natural_size),
+      mailbox_holder_(mailbox_holder.Pass()),
       shared_memory_handle_(base::SharedMemory::NULLHandle()),
       timestamp_(timestamp),
       end_of_stream_(end_of_stream) {
   DCHECK(IsValidConfig(format_, coded_size_, visible_rect_, natural_size_));
 
   memset(&strides_, 0, sizeof(strides_));
   memset(&data_, 0, sizeof(data_));
 }
 
 VideoFrame::~VideoFrame() {
   if (!mailbox_holder_release_cb_.is_null()) {
-    base::ResetAndReturn(&mailbox_holder_release_cb_)
-        .Run(mailbox_holder_.Pass());
+    std::vector<uint32> release_sync_points;
+    {
+      base::AutoLock locker(release_sync_point_lock_);
+      release_sync_points_.swap(release_sync_points);
+    }
+    base::ResetAndReturn(&mailbox_holder_release_cb_).Run(release_sync_points);
   }
   if (!no_longer_needed_cb_.is_null())
     base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
 bool VideoFrame::IsValidPlane(size_t plane) const {
   return (plane < NumPlanes(format_));
 }
 
 int VideoFrame::stride(size_t plane) const {
@@ skipping 51 matching lines @@
   // Intentionally leave out non-production formats.
   NOTREACHED() << "Unsupported video frame format: " << format_;
   return 0;
 }
 
 uint8* VideoFrame::data(size_t plane) const {
   DCHECK(IsValidPlane(plane));
   return data_[plane];
 }
 
-gpu::MailboxHolder* VideoFrame::mailbox_holder() const {
+const gpu::MailboxHolder* VideoFrame::mailbox_holder() const {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
   return mailbox_holder_.get();
 }
 
 base::SharedMemoryHandle VideoFrame::shared_memory_handle() const {
   return shared_memory_handle_;
 }
 
+void VideoFrame::AppendReleaseSyncPoint(uint32 sync_point) {
+  DCHECK_EQ(format_, NATIVE_TEXTURE);
+  if (!sync_point)
+    return;
+  base::AutoLock locker(release_sync_point_lock_);
+  release_sync_points_.push_back(sync_point);
+}
+
 void VideoFrame::HashFrameForTesting(base::MD5Context* context) {
   for (int plane = 0; plane < kMaxPlanes; ++plane) {
     if (!IsValidPlane(plane))
       break;
     for (int row = 0; row < rows(plane); ++row) {
       base::MD5Update(context, base::StringPiece(
           reinterpret_cast<char*>(data(plane) + stride(plane) * row),
           row_bytes(plane)));
     }
   }
 }
 
 }  // namespace media