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"
 #include "base/logging.h"
 #include "base/memory/aligned_memory.h"
 #include "base/strings/string_piece.h"
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "media/base/limits.h"
 #include "media/base/video_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
+#if defined(OS_MACOSX)
+#include <CoreVideo/CoreVideo.h>
+#endif
+
 namespace media {
 
 static inline size_t RoundUp(size_t value, size_t alignment) {
   // Check that |alignment| is a power of 2.
   DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1)));
   return ((value + (alignment - 1)) & ~(alignment - 1));
 }
 
 // Rounds up |coded_size| if necessary for |format|.
 static gfx::Size AdjustCodedSize(VideoFrame::Format format,
@@ skipping 242 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

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

nit: capitalization and punctuation

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

Acknowledged.

+  if (cv_format == kCVPixelFormatType_420YpCbCr8Planar) {
+    format = Format::I420;
+  } else if (cv_format == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange) {

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

This is only available on 10.7 and later. This will not compile.

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

Wow, are you telling me Chrome needs to build on 10.6? That is positively
ancient... And that won't be tenable with the new codesigning requirements Apple
is about to enforce.

Anyways, I'll conditionally support this format when the builder is >= 10.7 and
ensure it won't break if the symbol is not available (which should be automatic
via the availability declaration on the symbol, assuming chrome builds with the
right min-version compiler/linker flags).

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

Yes. Build and run. This has been the requirement for at least two years.
They claim that the signatures will be backwards compatible.
You could also just use the literal value.

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

I'm brand new to Chrome development, I didn't know that. The runtime requirement
is fine, but building on really old toolchains is harder.
Yes, however the technote on the details of codesigning
(https://developer.apple.com/library/prerelease/mac/technotes/tn2206/_index.html)
specifically calls out that the codesigning process itself must happen on a
>=10.9 host because the codesigning machinery is provided by system frameworks
and not by the codesign binary itself. I suppose we could have dedicated
codesigning bots.
Yeah I remembered post-comment that they were just enums. I'd rather make the
code conditional than hardcode a constant.

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

Actually, it's quite trivial. You just need go/mac-10.6-sdk.
We already have dedicated signing bots because of key material isolation.

+    format = Format::NV12;
+  } else if (cv_format == kCVPixelFormatType_444YpCbCr8) {
+    format = Format::YV24;
+  } 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