media: Let VideoFrame carry more than one native texture.

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 120 matching lines @@
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::ARGB:
       NOTIMPLEMENTED();
       return nullptr;
   }
 
   // Since we're creating a new YUV frame (and allocating memory for it
   // ourselves), we can pad the requested |coded_size| if necessary if the
   // request does not line up on sample boundaries.
   const gfx::Size new_coded_size = AdjustCodedSize(format, coded_size);
-  DCHECK(IsValidConfig(format, new_coded_size, visible_rect, natural_size));
+  DCHECK(IsValidConfig(format, TEXTURE_NONE, new_coded_size, visible_rect,
+                       natural_size));
 
+  gpu::MailboxHolder mailboxes[kMaxPlanes];
   scoped_refptr<VideoFrame> frame(
-      new VideoFrame(format,
-                     new_coded_size,
-                     visible_rect,
-                     natural_size,
-                     scoped_ptr<gpu::MailboxHolder>(),
-                     timestamp,
-                     false));
+      new VideoFrame(format, new_coded_size, visible_rect, natural_size,
+                     mailboxes, TEXTURE_NONE, 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 20 matching lines @@
       return "ARGB";
     case VideoFrame::YV12HD:
       return "YV12HD";
   }
   NOTREACHED() << "Invalid videoframe format provided: " << format;
   return "";
 }
 
 // static
 bool VideoFrame::IsValidConfig(VideoFrame::Format format,
+                               VideoFrame::TextureFormat texture_format,
                                const gfx::Size& coded_size,
                                const gfx::Rect& visible_rect,
                                const gfx::Size& natural_size) {
   // Check maximum limits for all formats.
   if (coded_size.GetArea() > limits::kMaxCanvas ||
       coded_size.width() > limits::kMaxDimension ||
       coded_size.height() > limits::kMaxDimension ||
       visible_rect.x() < 0 || visible_rect.y() < 0 ||
       visible_rect.right() > coded_size.width() ||
       visible_rect.bottom() > coded_size.height() ||
       natural_size.GetArea() > limits::kMaxCanvas ||
       natural_size.width() > limits::kMaxDimension ||
       natural_size.height() > limits::kMaxDimension)
     return false;
 
   // Check format-specific width/height requirements.
   switch (format) {
     case VideoFrame::UNKNOWN:
       return (coded_size.IsEmpty() && visible_rect.IsEmpty() &&
               natural_size.IsEmpty());
 
     // NATIVE_TEXTURE and HOLE have no software-allocated buffers and are
     // allowed to skip the below check.
     case VideoFrame::NATIVE_TEXTURE:
+      return texture_format != VideoFrame::TEXTURE_NONE;
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
       return true;
 
     case VideoFrame::YV24:
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
     case VideoFrame::I420:
     case VideoFrame::YV12A:
@@ skipping 11 matching lines @@
              !coded_size.IsEmpty() && !visible_rect.IsEmpty() &&
              !natural_size.IsEmpty();
   }
 
   NOTREACHED();
   return false;
 }
 
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapNativeTexture(
-    scoped_ptr<gpu::MailboxHolder> mailbox_holder,
+    const gpu::MailboxHolder& mailbox_holder,
     const ReleaseMailboxCB& mailbox_holder_release_cb,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp,
     bool allow_overlay) {
-  scoped_refptr<VideoFrame> frame(new VideoFrame(NATIVE_TEXTURE,
-                                                 coded_size,
-                                                 visible_rect,
-                                                 natural_size,
-                                                 mailbox_holder.Pass(),
-                                                 timestamp,
-                                                 false));
-  frame->mailbox_holder_release_cb_ = mailbox_holder_release_cb;
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
+  mailbox_holders[0] = mailbox_holder;

[reveman, 2015/05/03 16:13:27]

s/0/kARGBPlan/

[Daniele Castagna, 2015/05/04 15:00:15]

Done.

+  scoped_refptr<VideoFrame> frame(
+      new VideoFrame(NATIVE_TEXTURE, coded_size, visible_rect, natural_size,
+                     mailbox_holders, TEXTURE_RGBA, timestamp, false));
+  frame->mailbox_holders_release_cb_ = mailbox_holder_release_cb;
   frame->allow_overlay_ = allow_overlay;
-
   return frame;
 }
 
+// static
+scoped_refptr<VideoFrame> VideoFrame::WrapYUVNativeTextures(
+    const gpu::MailboxHolder& y_mailbox_holder,
+    const gpu::MailboxHolder& u_mailbox_holder,
+    const gpu::MailboxHolder& v_mailbox_holder,
+    const ReleaseMailboxCB& mailbox_holder_release_cb,
+    const gfx::Size& coded_size,
+    const gfx::Rect& visible_rect,
+    const gfx::Size& natural_size,
+    base::TimeDelta timestamp,
+    bool allow_overlay) {
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
+  mailbox_holders[kYPlane] = y_mailbox_holder;
+  mailbox_holders[kUPlane] = u_mailbox_holder;
+  mailbox_holders[kVPlane] = v_mailbox_holder;
+  scoped_refptr<VideoFrame> frame(
+      new VideoFrame(NATIVE_TEXTURE, coded_size, visible_rect, natural_size,
+                     mailbox_holders, TEXTURE_YUV_R8R8R8, timestamp, false));
+  frame->mailbox_holders_release_cb_ = mailbox_holder_release_cb;
+  frame->allow_overlay_ = allow_overlay;
+  return frame;
+}
+
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalPackedMemory(
     Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     uint8* data,
     size_t data_size,
     base::SharedMemoryHandle handle,
     size_t data_offset,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
   const gfx::Size new_coded_size = AdjustCodedSize(format, coded_size);
 
-  if (!IsValidConfig(format, new_coded_size, visible_rect, natural_size))
+  if (!IsValidConfig(format, TEXTURE_NONE, new_coded_size, visible_rect,
+                     natural_size))
     return NULL;
   if (data_size < AllocationSize(format, new_coded_size))
     return NULL;
 
   switch (format) {
     case VideoFrame::I420: {
+      gpu::MailboxHolder mailbox_holders[kMaxPlanes];
       scoped_refptr<VideoFrame> frame(
-          new VideoFrame(format,
-                         new_coded_size,
-                         visible_rect,
-                         natural_size,
-                         scoped_ptr<gpu::MailboxHolder>(),
-                         timestamp,
-                         false));
+          new VideoFrame(format, new_coded_size, visible_rect, natural_size,
+                         mailbox_holders, TEXTURE_NONE, timestamp, false));
       frame->shared_memory_handle_ = handle;
       frame->shared_memory_offset_ = data_offset;
       frame->strides_[kYPlane] = new_coded_size.width();
       frame->strides_[kUPlane] = new_coded_size.width() / 2;
       frame->strides_[kVPlane] = new_coded_size.width() / 2;
       frame->data_[kYPlane] = data;
       frame->data_[kUPlane] = data + new_coded_size.GetArea();
       frame->data_[kVPlane] = data + (new_coded_size.GetArea() * 5 / 4);
       frame->no_longer_needed_cb_ = no_longer_needed_cb;
       return frame;
@@ skipping 12 matching lines @@
     const gfx::Size& natural_size,
     int32 y_stride,
     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) {
   const gfx::Size new_coded_size = AdjustCodedSize(format, coded_size);
-  CHECK(IsValidConfig(format, new_coded_size, visible_rect, natural_size));
+  CHECK(IsValidConfig(format, TEXTURE_NONE, new_coded_size, visible_rect,
+                      natural_size));
 
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
   scoped_refptr<VideoFrame> frame(
-      new VideoFrame(format,
-                     new_coded_size,
-                     visible_rect,
-                     natural_size,
-                     scoped_ptr<gpu::MailboxHolder>(),
-                     timestamp,
-                     false));
+      new VideoFrame(format, new_coded_size, visible_rect, natural_size,
+                     mailbox_holders, TEXTURE_NONE, 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;
 }
 
 #if defined(OS_POSIX)
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalDmabufs(
     Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     const std::vector<int> dmabuf_fds,
     base::TimeDelta timestamp,
     const base::Closure& no_longer_needed_cb) {
-  if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
+  if (!IsValidConfig(format, TEXTURE_NONE, coded_size, visible_rect,
+                     natural_size))
     return NULL;
 
   // TODO(posciak): This is not exactly correct, it's possible for one
   // buffer to contain more than one plane.
   if (dmabuf_fds.size() != NumPlanes(format)) {
     LOG(FATAL) << "Not enough dmabuf fds provided!";
     return NULL;
   }
 
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
   scoped_refptr<VideoFrame> frame(
-      new VideoFrame(format,
-                     coded_size,
-                     visible_rect,
-                     natural_size,
-                     scoped_ptr<gpu::MailboxHolder>(),
-                     timestamp,
-                     false));
+      new VideoFrame(format, coded_size, visible_rect, natural_size,
+                     mailbox_holders, TEXTURE_NONE, timestamp, false));
 
   for (size_t i = 0; i < dmabuf_fds.size(); ++i) {
     int duped_fd = HANDLE_EINTR(dup(dmabuf_fds[i]));
     if (duped_fd == -1) {
       // The already-duped in previous iterations fds will be closed when
       // the partially-created frame drops out of scope here.
       DLOG(ERROR) << "Failed duplicating a dmabuf fd";
       return NULL;
     }
 
@@ skipping 29 matching lines @@
     format = Format::NV12;
   } else {
     DLOG(ERROR) << "CVPixelBuffer format not supported: " << cv_format;
     return NULL;
   }
 
   const gfx::Size coded_size(CVImageBufferGetEncodedSize(cv_pixel_buffer));
   const gfx::Rect visible_rect(CVImageBufferGetCleanRect(cv_pixel_buffer));
   const gfx::Size natural_size(CVImageBufferGetDisplaySize(cv_pixel_buffer));
 
-  if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
+  if (!IsValidConfig(format, TEXTURE_NONE, coded_size, visible_rect,
+                     natural_size))
     return NULL;
 
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
   scoped_refptr<VideoFrame> frame(
-      new VideoFrame(format,
-                     coded_size,
-                     visible_rect,
-                     natural_size,
-                     scoped_ptr<gpu::MailboxHolder>(),
-                     timestamp,
-                     false));
+      new VideoFrame(format, new_coded_size, visible_rect, natural_size,
+                     mailbox_holders, TEXTURE_NONE, timestamp, false));
 
   frame->cv_pixel_buffer_.reset(cv_pixel_buffer, base::scoped_policy::RETAIN);
   return frame;
 }
 #endif
 
 // 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_NE(frame->format(), NATIVE_TEXTURE);
 
   DCHECK(frame->visible_rect().Contains(visible_rect));
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
   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()));
+      new VideoFrame(frame->format(), frame->coded_size(), visible_rect,
+                     natural_size, mailbox_holders, TEXTURE_NONE,
+                     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);
+  gpu::MailboxHolder mailbox_holders[kMaxPlanes];
+  return new VideoFrame(VideoFrame::UNKNOWN, gfx::Size(), gfx::Rect(),
+                        gfx::Size(), mailbox_holders, TEXTURE_NONE,
+                        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(
       VideoFrame::YV12, size, gfx::Rect(size), size, timestamp);
   FillYUV(frame.get(), y, u, v);
@@ skipping 25 matching lines @@
 // This block and other blocks wrapped around #if defined(VIDEO_HOLE) is not
 // 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,
-                     scoped_ptr<gpu::MailboxHolder>(),
-                     base::TimeDelta(),
-                     false));
+  DCHECK(IsValidConfig(VideoFrame::HOLE, TEXTURE_NONE, size, gfx::Rect(size),
+                       size));
+  scoped_refptr<VideoFrame> frame(new VideoFrame(VideoFrame::HOLE, size,
+                                                 gfx::Rect(size), size,
+                                                 nullptr,  // mailbox holders
+                                                 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 12 matching lines @@
       return 3;
     case VideoFrame::YV12A:
       return 4;
     case VideoFrame::UNKNOWN:
       break;
   }
   NOTREACHED() << "Unsupported video frame format: " << format;
   return 0;
 }
 
+// static
+size_t VideoFrame::NumTextures(TextureFormat texture_format) {
+  switch (texture_format) {
+    case TEXTURE_RGBA:
+      return 1;
+    case TEXTURE_YUV_R8R8R8:
+      return 3;
+    case TEXTURE_NONE:
+      NOTREACHED();
+      return 0;
+  }
+
+  NOTREACHED();
+  return 0;
+}
 
 // static
 size_t VideoFrame::AllocationSize(Format format, const gfx::Size& coded_size) {
   size_t total = 0;
   for (size_t i = 0; i < NumPlanes(format); ++i)
     total += PlaneAllocationSize(format, i, coded_size);
   return total;
 }
 
 // static
@@ skipping 82 matching lines @@
   for (size_t plane = 0; plane < VideoFrame::NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   no_longer_needed_cb_ = base::Bind(&ReleaseData, data);
 }
 
 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,
+                       const gpu::MailboxHolder mailbox_holders[kMaxPlanes],
+                       VideoFrame::TextureFormat texture_format,
                        base::TimeDelta timestamp,
                        bool end_of_stream)
     : format_(format),
+      texture_format_(texture_format),
       coded_size_(coded_size),
       visible_rect_(visible_rect),
       natural_size_(natural_size),
-      mailbox_holder_(mailbox_holder.Pass()),
       shared_memory_handle_(base::SharedMemory::NULLHandle()),
       shared_memory_offset_(0),
       timestamp_(timestamp),
       release_sync_point_(0),
       end_of_stream_(end_of_stream),
       allow_overlay_(false) {
-  DCHECK(IsValidConfig(format_, coded_size_, visible_rect_, natural_size_));
-
+  DCHECK(IsValidConfig(format_, texture_format_, coded_size_, visible_rect_,
+                       natural_size_));
+  memcpy(&mailbox_holders_, mailbox_holders, sizeof(mailbox_holders_));
   memset(&strides_, 0, sizeof(strides_));
   memset(&data_, 0, sizeof(data_));
 }
 
 VideoFrame::~VideoFrame() {
-  if (!mailbox_holder_release_cb_.is_null()) {
+  if (!mailbox_holders_release_cb_.is_null()) {
     uint32 release_sync_point;
     {
       // To ensure that changes to |release_sync_point_| are visible on this
       // thread (imply a memory barrier).
       base::AutoLock locker(release_sync_point_lock_);
       release_sync_point = release_sync_point_;
     }
-    base::ResetAndReturn(&mailbox_holder_release_cb_).Run(release_sync_point);
+    base::ResetAndReturn(&mailbox_holders_release_cb_).Run(release_sync_point);
   }
   if (!no_longer_needed_cb_.is_null())
     base::ResetAndReturn(&no_longer_needed_cb_).Run();
 }
 
 // static
 bool VideoFrame::IsValidPlane(size_t plane, VideoFrame::Format format) {
   return (plane < NumPlanes(format));
 }
 
@@ skipping 57 matching lines @@
          stride(plane) * (offset.y() / subsample.height()) +  // Row offset.
          BytesPerElement(format_, plane) *                    // Column offset.
              (offset.x() / subsample.width());
 }
 
 uint8* VideoFrame::visible_data(size_t plane) {
   return const_cast<uint8*>(
       static_cast<const VideoFrame*>(this)->visible_data(plane));
 }
 
-const gpu::MailboxHolder* VideoFrame::mailbox_holder() const {
+const gpu::MailboxHolder& VideoFrame::mailbox_holder(size_t texture) const {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
-  return mailbox_holder_.get();
+  DCHECK_LT(texture, NumTextures(texture_format_));
+  return mailbox_holders_[texture];
 }
 
 base::SharedMemoryHandle VideoFrame::shared_memory_handle() const {
   return shared_memory_handle_;
 }
 
 size_t VideoFrame::shared_memory_offset() const {
   return shared_memory_offset_;
 }
 
 void VideoFrame::UpdateReleaseSyncPoint(SyncPointClient* client) {
   DCHECK_EQ(format_, NATIVE_TEXTURE);
   base::AutoLock locker(release_sync_point_lock_);
   // Must wait on the previous sync point before inserting a new sync point so
-  // that |mailbox_holder_release_cb_| guarantees the previous sync point
+  // that |mailbox_holders_release_cb_| guarantees the previous sync point
   // occurred when it waits on |release_sync_point_|.
   if (release_sync_point_)
     client->WaitSyncPoint(release_sync_point_);
   release_sync_point_ = client->InsertSyncPoint();
 }
 
 #if defined(OS_POSIX)
 int VideoFrame::dmabuf_fd(size_t plane) const {
   return dmabuf_fds_[plane].get();
 }
 #endif
 
 #if defined(OS_MACOSX)
 CVPixelBufferRef VideoFrame::cv_pixel_buffer() const {
   return cv_pixel_buffer_.get();
 }
 #endif
 
 void VideoFrame::HashFrameForTesting(base::MD5Context* context) {
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane) {
     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