Mac: Use AVSampleBufferDisplayLayer for 4:2:0 surfaces

content/common/gpu/ca_layer_tree_mac.mm

 // Copyright 2016 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 "content/common/gpu/ca_layer_tree_mac.h"
 
+#include <AVFoundation/AVFoundation.h>
+#include <CoreVideo/CoreVideo.h>
+
 #include "base/command_line.h"
 #include "base/mac/sdk_forward_declarations.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/cocoa/animation_utils.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/gfx/geometry/dip_util.h"
 

[ccameron, 2016/03/23 08:57:10]

I tried putting this into sdk_forward_declarations.h and that seemed to be out
of control (it started pulling in headers from CoreVideo, CoreMedia, and
AVFoundation) ... this localized version seems more reasonable to me.

+#if !defined(MAC_OS_X_VERSION_10_8) || \
+    MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_8

[erikchen, 2016/03/23 17:44:59]

I assume this will no longer be required after we bump the deployment target to
10.8+?

[ccameron, 2016/03/23 18:26:21]

Exactly.

+BASE_EXPORT extern NSString* const AVLayerVideoGravityResize;

[erikchen, 2016/03/23 17:45:00]

BASE_EXPORT?

[ccameron, 2016/03/23 18:26:21]

Mmh, should have removed that when I removed these from base. Gone now.

+BASE_EXPORT extern "C" void NSAccessibilityPostNotificationWithUserInfo(
+    id object,
+    NSString* notification,
+    NSDictionary* user_info);
+BASE_EXPORT extern "C" OSStatus CMSampleBufferCreateForImageBuffer(
+    CFAllocatorRef,
+    CVImageBufferRef,
+    Boolean dataReady,
+    CMSampleBufferMakeDataReadyCallback,
+    void*,
+    CMVideoFormatDescriptionRef,
+    const CMSampleTimingInfo*,
+    CMSampleBufferRef*);
+BASE_EXPORT extern "C" CFArrayRef CMSampleBufferGetSampleAttachmentsArray(
+    CMSampleBufferRef,
+    Boolean);
+BASE_EXPORT extern "C" OSStatus CMVideoFormatDescriptionCreateForImageBuffer(
+    CFAllocatorRef,
+    CVImageBufferRef,
+    CMVideoFormatDescriptionRef*);
+BASE_EXPORT extern "C" CMTime CMTimeMake(int64_t, int32_t);
+BASE_EXPORT extern CFStringRef const kCMSampleAttachmentKey_DisplayImmediately;
+BASE_EXPORT extern const CMTime kCMTimeInvalid;
+#endif  // MAC_OS_X_VERSION_10_8
+
 namespace content {
 
+namespace {
+
+bool AVSampleBufferDisplayLayerEnqueueIOSurface(

[erikchen, 2016/03/23 17:45:00]

Can you add a comment on the ownership semantics of this function? It looks like
on success, io_surface gets retained by cv_pixel_buffer, which in turn becomes
owned by av_layer?

[ccameron, 2016/03/23 18:26:21]

Added a comment. I just said that the io_surface is retained and marked in-use
until it is displayed. In practice cv_pixel_buffer is an intermediate in that.

+    AVSampleBufferDisplayLayer* av_layer,
+    IOSurfaceRef io_surface) {
+  OSStatus os_status = noErr;
+  CVReturn cv_return = kCVReturnSuccess;
+
+  base::ScopedCFTypeRef<CFDictionaryRef> pixel_buffer_attributes;
+  base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
+  cv_return = CVPixelBufferCreateWithIOSurface(
+      kCFAllocatorDefault, io_surface, pixel_buffer_attributes.get(),

[erikchen, 2016/03/23 17:44:59]

Isn't pixel_buffer_attributes.get() always nullptr?

[erikchen, 2016/03/23 17:45:00]

shouldn't we pass null to use the defualt allocator? Mostly looking for
consistency between this and CMVideoFormatDescriptionCreateForImageBuffer

[ccameron, 2016/03/23 18:26:20]

I spent so long trying to put random things in that dictionary that I didn't
want to forget it completely. nullptr now.

[ccameron, 2016/03/23 18:26:21]

Changed to nullptr.

+      cv_pixel_buffer.InitializeInto());
+  if (cv_return) {

[erikchen, 2016/03/23 17:45:00]

I think you want cv_return != kCVReturnSuccess

[ccameron, 2016/03/23 18:26:20]

Done (kCVReturnSuccess == 0).

+    LOG(ERROR) << "CVPixelBufferCreateWithIOSurface failed with " << cv_return;
+    return false;
+  }
+
+  base::ScopedCFTypeRef<CMVideoFormatDescriptionRef> video_info;
+  os_status = CMVideoFormatDescriptionCreateForImageBuffer(
+      NULL, cv_pixel_buffer, video_info.InitializeInto());
+  if (os_status) {

[erikchen, 2016/03/23 17:45:00]

use proper conditional here and later in function.

[ccameron, 2016/03/23 18:26:21]

Done.

+    LOG(ERROR) << "CMVideoFormatDescriptionCreateForImageBuffer failed with "
+               << os_status;
+    return false;
+  }
+
+  CMTime frame_time = CMTimeMake(0, 30);

[erikchen, 2016/03/23 17:44:59]

Where did this number 30 come from?

[ccameron, 2016/03/23 18:26:21]

Added a comment saying that frame time doesn't matter because we're displaying
immediately. And changed the denominator to 1.

+  CMSampleTimingInfo timing_info = {frame_time, frame_time, kCMTimeInvalid};
+
+  base::ScopedCFTypeRef<CMSampleBufferRef> sample_buffer = NULL;

[erikchen, 2016/03/23 17:45:00]

s/NULL/nullptr

[ccameron, 2016/03/23 18:26:21]

Done.

+  os_status = CMSampleBufferCreateForImageBuffer(
+      kCFAllocatorDefault, cv_pixel_buffer, YES, NULL, NULL, video_info,
+      &timing_info, sample_buffer.InitializeInto());
+  if (os_status) {
+    LOG(ERROR) << "CMSampleBufferCreateForImageBuffer failed with "
+               << os_status;
+    return false;
+  }
+
+  CFArrayRef attachments =
+      CMSampleBufferGetSampleAttachmentsArray(sample_buffer, YES);
+  if (!attachments) {
+    LOG(ERROR) << "CMSampleBufferGetSampleAttachmentsArray failed";
+    return false;
+  }
+  CFMutableDictionaryRef attachments_dictionary =

[erikchen, 2016/03/23 17:45:00]

Check that array has size >=1 first

[ccameron, 2016/03/23 18:26:20]

Done.

+      reinterpret_cast<CFMutableDictionaryRef>(
+          const_cast<void*>(CFArrayGetValueAtIndex(attachments, 0)));
+  if (!attachments_dictionary) {
+    LOG(ERROR) << "Failed to get attachments dictionary";
+    return false;
+  }
+  CFDictionarySetValue(attachments_dictionary,
+                       kCMSampleAttachmentKey_DisplayImmediately,
+                       kCFBooleanTrue);
+
+  [av_layer enqueueSampleBuffer:sample_buffer];
+  return true;
+}
+
+}  // namespace
+
 CALayerTree::CALayerTree() {}
 CALayerTree::~CALayerTree() {}
 
 bool CALayerTree::ScheduleCALayer(
     bool is_clipped,
     const gfx::Rect& clip_rect,
     unsigned sorting_context_id,
     const gfx::Transform& transform,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
     const gfx::RectF& contents_rect,
@@ skipping 119 matching lines @@
     if (edge_aa_mask & GL_CA_LAYER_EDGE_BOTTOM_CHROMIUM)
       ca_edge_aa_mask |= kCALayerBottomEdge;
   }
 
   // Ensure that the IOSurface be in use as soon as it is added to a
   // ContentLayer, so that, by the time that the call to SwapBuffers completes,
   // all IOSurfaces that can be used as CALayer contents in the future will be
   // marked as InUse.
   if (io_surface)
     IOSurfaceIncrementUseCount(io_surface);
+
+  // Only allow 4:2:0 frames which fill the layer's contents to be promoted to
+  // AV layers.
+  if (IOSurfaceGetPixelFormat(io_surface) ==
+          kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange &&
+      contents_rect == gfx::RectF(0, 0, 1, 1)) {
+    use_av_layer = true;
+  }
 }
 
 CALayerTree::ContentLayer::ContentLayer(ContentLayer&& layer)
     : io_surface(layer.io_surface),
       contents_rect(layer.contents_rect),
       rect(layer.rect),
       background_color(layer.background_color),
       ca_edge_aa_mask(layer.ca_edge_aa_mask),
       opacity(layer.opacity),
-      ca_layer(layer.ca_layer) {
+      ca_layer(layer.ca_layer),
+      av_layer(layer.av_layer),
+      use_av_layer(layer.use_av_layer) {
   DCHECK(!layer.ca_layer);
   layer.ca_layer.reset();
+  layer.av_layer.reset();
   // See remarks in the non-move constructor.
   if (io_surface)
     IOSurfaceIncrementUseCount(io_surface);
 }
 
 CALayerTree::ContentLayer::~ContentLayer() {
   [ca_layer removeFromSuperlayer];
   // By the time the destructor is called, the IOSurface will have been passed
   // to the WindowServer, and will remain InUse by the WindowServer as long as
   // is needed to avoid recycling bugs.
@@ skipping 202 matching lines @@
 
 void CALayerTree::ContentLayer::CommitToCA(CALayer* superlayer,
                                            ContentLayer* old_layer,
                                            float scale_factor) {
   bool update_contents = true;
   bool update_contents_rect = true;
   bool update_rect = true;
   bool update_background_color = true;
   bool update_ca_edge_aa_mask = true;
   bool update_opacity = true;
-  if (old_layer) {
+  if (old_layer && old_layer->use_av_layer == use_av_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
+    std::swap(av_layer, old_layer->av_layer);
     update_contents = old_layer->io_surface != io_surface;
     update_contents_rect = old_layer->contents_rect != contents_rect;
     update_rect = old_layer->rect != rect;
     update_background_color = old_layer->background_color != background_color;
     update_ca_edge_aa_mask = old_layer->ca_edge_aa_mask != ca_edge_aa_mask;
     update_opacity = old_layer->opacity != opacity;
   } else {
-    ca_layer.reset([[CALayer alloc] init]);
+    if (use_av_layer) {
+      av_layer.reset([[AVSampleBufferDisplayLayer alloc] init]);
+      ca_layer.reset([av_layer retain]);
+      [av_layer setVideoGravity:AVLayerVideoGravityResize];
+    } else {
+      ca_layer.reset([[CALayer alloc] init]);

[erikchen, 2016/03/23 17:44:59]

Shouldn't we reset av_layer as well [to release a reference?]

[ccameron, 2016/03/23 18:26:20]

We construct a new CALayerTree every frame (yeah, crazy, I know), so everything
here gets re-set every frame. If it's going to have a CALayer, it needs allocate
it or pull it from |old_layer|.

+    }
     [ca_layer setAnchorPoint:CGPointZero];
     [superlayer addSublayer:ca_layer];
   }
   DCHECK_EQ([ca_layer superlayer], superlayer);
   bool update_anything = update_contents || update_contents_rect ||
                          update_rect || update_background_color ||
                          update_ca_edge_aa_mask || update_opacity;
-
-  if (update_contents) {
-    [ca_layer setContents:static_cast<id>(io_surface.get())];
-    if ([ca_layer respondsToSelector:(@selector(setContentsScale:))])
-      [ca_layer setContentsScale:scale_factor];
+  if (use_av_layer) {
+    if (update_contents)
+      AVSampleBufferDisplayLayerEnqueueIOSurface(av_layer, io_surface);
+  } else {
+    if (update_contents) {
+      [ca_layer setContents:static_cast<id>(io_surface.get())];
+      if ([ca_layer respondsToSelector:(@selector(setContentsScale:))])
+        [ca_layer setContentsScale:scale_factor];
+    }
+    if (update_contents_rect)

[erikchen, 2016/03/23 17:45:00]

What if we're using a new av layer and need to update the contents rect (to
become 0, 0, 1, 1)? 

[ccameron, 2016/03/23 18:26:20]

We only use_av_layer when the content rect is (0,0,1,1) -- we may be able to
relax this, but I didn't bother with it.

If the content rect changed from not-(0,0,1,1) to (0,0,1,1), then
"old_layer->use_av_layer == use_av_layer" will make us create a new layer and
set everything again.

+      [ca_layer setContentsRect:contents_rect.ToCGRect()];
   }
-  if (update_contents_rect)
-    [ca_layer setContentsRect:contents_rect.ToCGRect()];
   if (update_rect) {
     gfx::RectF dip_rect = gfx::RectF(rect);
     dip_rect.Scale(1 / scale_factor);
     [ca_layer setPosition:CGPointMake(dip_rect.x(), dip_rect.y())];
     [ca_layer setBounds:CGRectMake(0, 0, dip_rect.width(), dip_rect.height())];
   }
   if (update_background_color) {
     CGFloat rgba_color_components[4] = {
         SkColorGetR(background_color) / 255.,
         SkColorGetG(background_color) / 255.,
         SkColorGetB(background_color) / 255.,
         SkColorGetA(background_color) / 255.,
     };
     base::ScopedCFTypeRef<CGColorRef> srgb_background_color(CGColorCreate(
         CGColorSpaceCreateWithName(kCGColorSpaceSRGB), rgba_color_components));
     [ca_layer setBackgroundColor:srgb_background_color];
   }
   if (update_ca_edge_aa_mask)
     [ca_layer setEdgeAntialiasingMask:ca_edge_aa_mask];
   if (update_opacity)
     [ca_layer setOpacity:opacity];
 
   static bool show_borders = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kShowMacOverlayBorders);
   if (show_borders) {
     base::ScopedCFTypeRef<CGColorRef> color;
     if (update_anything) {
-      // Pink represents a CALayer that changed this frame.
-      color.reset(CGColorCreateGenericRGB(1, 0, 1, 1));
+      if (use_av_layer) {
+        // Green represents an AV layer that changed this frame.
+        color.reset(CGColorCreateGenericRGB(0, 1, 0, 1));
+      } else {
+        // Pink represents a CALayer that changed this frame.
+        color.reset(CGColorCreateGenericRGB(1, 0, 1, 1));
+      }
     } else {
       // Grey represents a CALayer that has not changed.
       color.reset(CGColorCreateGenericRGB(0, 0, 0, 0.1));
     }
     [ca_layer setBorderWidth:1];
     [ca_layer setBorderColor:color];
   }
 }
 
 }  // namespace content