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

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 260 matching lines @@
     // Data is accessible only via fds.
     frame->data_[i] = NULL;
     frame->strides_[i] = 0;
   }
 
   frame->no_longer_needed_cb_ = no_longer_needed_cb;
   return frame;
 }
 #endif
 
+#if defined(OS_MACOSX)
+// static
+scoped_refptr<VideoFrame> VideoFrame::WrapCVPixelBuffer(
+    CVPixelBufferRef cv_pixel_buffer,
+    base::TimeDelta timestamp) {
+  DCHECK(cv_pixel_buffer);
+  DCHECK(CFGetTypeID(cv_pixel_buffer) == CVPixelBufferGetTypeID());
+
+  OSType cv_format = CVPixelBufferGetPixelFormatType(cv_pixel_buffer);
+  Format format;
+  // There are very few compatible CV pixel formats, so just check each.
+  if (cv_format == kCVPixelFormatType_420YpCbCr8Planar) {
+    format = Format::I420;
+  } else if (cv_format == kCVPixelFormatType_444YpCbCr8) {
+    format = Format::YV24;
+  }
+#if (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1070) || \
+    (__IPHONE_OS_VERSION_MIN_REQUIRED >= 40000)

[Robert Sesek, 2014/08/07 18:00:15]

Does //media even get compiled on iOS? If not, remove, or just use the literal
'420v' without guards.

[jfroy, 2014/08/07 18:08:20]

It is for my purpose. I can still switch to using the literal if you prefer. I
don't know which way is more "chrome"-y.

[Robert Sesek, 2014/08/07 18:14:44]

If this code doesn't build on iOS, then remove the iOS guard. I think it's
perfectly fine to use the literal, since its definition is part of the headers.
Just leave a "TODO(jfroy): Switch to the constant
kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange in the 10.7 SDK." comment.

+  else if (cv_format == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange) {
+    format = Format::NV12;
+  }
+#endif
+  else {
+    DLOG(ERROR) << "CVPixelBuffer format not supported: " << cv_format;
+    return NULL;
+  }
+
+  gfx::Size coded_size(CVImageBufferGetEncodedSize(cv_pixel_buffer));
+  gfx::Rect visible_rect(CVImageBufferGetCleanRect(cv_pixel_buffer));
+  gfx::Size natural_size(CVImageBufferGetDisplaySize(cv_pixel_buffer));
+
+  if (!IsValidConfig(format, coded_size, visible_rect, natural_size))
+    return NULL;
+
+  scoped_refptr<VideoFrame> frame(
+      new VideoFrame(format,
+                     coded_size,
+                     visible_rect,
+                     natural_size,
+                     scoped_ptr<gpu::MailboxHolder>(),
+                     timestamp,
+                     false));
+
+  frame->cv_pixel_buffer_.reset(cv_pixel_buffer, base::scoped_policy::RETAIN);
+  return frame;
+}
+#endif
+
 // static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalYuvData(
     Format format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     int32 y_stride,
     int32 u_stride,
     int32 v_stride,
     uint8* y_data,
@@ skipping 554 matching lines @@
     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 (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