Extend media::VideoFrame to wrap CVPixelBuffer on OS X and iOS.

media/base/video_frame.h

 // 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.
 
 #ifndef MEDIA_BASE_VIDEO_FRAME_H_
 #define MEDIA_BASE_VIDEO_FRAME_H_
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/md5.h"
 #include "base/memory/shared_memory.h"
 #include "base/synchronization/lock.h"
 #include "media/base/buffers.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/size.h"
 
 class SkBitmap;
 
+#if defined(OS_MACOSX)
+#include "base/mac/scoped_cftyperef.h"
+
+// From CoreVideo headers

[Robert Sesek, 2014/08/07 16:12:57]

Why can't you just include CoreVideo.h here?

[jfroy, 2014/08/07 16:22:14]

I thought the general guideline in chromium code was to forward-declare types
when possible to keep compile times low. Bringing in all of CoreVideo in this
header seems overkill.

I'm not overly fond of copying system type declarations either, but on the flip
side I can hardly see them ever changing.

[Robert Sesek, 2014/08/07 16:34:42]

No, don't forward-declare system types unless you have to for forward
declaration purposes. Pull in CoreVideo.h here.

[jfroy, 2014/08/07 16:52:46]

Acknowledged.

+typedef struct __CVBuffer *CVBufferRef;
+typedef CVBufferRef CVImageBufferRef;
+typedef CVImageBufferRef CVPixelBufferRef;
+#endif
+
 namespace gpu {
 struct MailboxHolder;
 }  // namespace gpu
 
 namespace media {
 
 class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe<VideoFrame> {
  public:
   enum {
     kFrameSizeAlignment = 16,
@@ skipping 111 matching lines @@
   static scoped_refptr<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);
 #endif
 
+#if defined(OS_MACOSX)
+  // Wraps provided CVPixelBuffer with a VideoFrame. The pixel buffer is
+  // retained for the lifetime of the VideoFrame and released upon destruction.
+  // The image data is only accessible via the pixel buffer, which could be
+  // backed by an IOSurface from another process. All the attributes of the
+  // VideoFrame are derived from pixel buffer, with the exception of the
+  // timestamp. If information is missing or is incompatible (for example, a
+  // pixel format that has no VideoFrame match), null is returned.
+  // http://crbug.com/401308
+  static scoped_refptr<VideoFrame> WrapCVPixelBuffer(
+      CVPixelBufferRef cv_pixel_buffer,
+      base::TimeDelta timestamp);
+#endif
+
   // Wraps external YUV data of the given parameters with a VideoFrame.
   // The returned VideoFrame does not own the data passed in. When the frame
   // is destroyed |no_longer_needed_cb.Run()| will be called.
   // TODO(sheu): merge this into WrapExternalSharedMemory().
   // http://crbug.com/270217
   static scoped_refptr<VideoFrame> WrapExternalYuvData(
       Format format,
       const gfx::Size& coded_size,
       const gfx::Rect& visible_rect,
       const gfx::Size& natural_size,
@@ skipping 83 matching lines @@
   const gpu::MailboxHolder* mailbox_holder() const;
 
   // Returns the shared-memory handle, if present
   base::SharedMemoryHandle shared_memory_handle() const;
 
 #if defined(OS_POSIX)
   // Returns backing dmabuf file descriptor for given |plane|, if present.
   int dmabuf_fd(size_t plane) const;
 #endif
 
+#if defined(OS_MACOSX)
+  // Returns the backing CVPixelBuffer, if present.
+  CVPixelBufferRef cv_pixel_buffer() const;
+#endif
+
   // Returns true if this VideoFrame represents the end of the stream.
   bool end_of_stream() const { return end_of_stream_; }
 
   base::TimeDelta timestamp() const {
     return timestamp_;
   }
   void set_timestamp(const base::TimeDelta& timestamp) {
     timestamp_ = timestamp;
   }
 
@@ skipping 69 matching lines @@
 
   // Shared memory handle, if this frame was allocated from shared memory.
   base::SharedMemoryHandle shared_memory_handle_;
 
 #if defined(OS_POSIX)
   // Dmabufs for each plane, if this frame is wrapping memory
   // acquired via dmabuf.
   base::ScopedFD dmabuf_fds_[kMaxPlanes];
 #endif
 
+#if defined(OS_MACOSX)
+  // CVPixelBuffer, if this frame is wrapping one.
+  base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer_;
+#endif
+
   base::Closure no_longer_needed_cb_;
 
   base::TimeDelta timestamp_;
 
   base::Lock release_sync_point_lock_;
   uint32 release_sync_point_;
 
   const bool end_of_stream_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(VideoFrame);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_VIDEO_FRAME_H_