Mac video: Enable AVSampleBufferDisplayLayer for h264

ui/accelerated_widget_mac/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 "ui/accelerated_widget_mac/ca_layer_tree_mac.h"
 
 #include <AVFoundation/AVFoundation.h>
 #include <CoreMedia/CoreMedia.h>
 #include <CoreVideo/CoreVideo.h>
 #include <GLES2/gl2extchromium.h>
@@ skipping 30 matching lines @@
     CMVideoFormatDescriptionRef*);
 extern "C" CMTime CMTimeMake(int64_t, int32_t);
 extern CFStringRef const kCMSampleAttachmentKey_DisplayImmediately;
 extern const CMTime kCMTimeInvalid;
 #endif  // MAC_OS_X_VERSION_10_8
 
 namespace ui {
 
 namespace {
 
-// This will enqueue |io_surface| to be drawn by |av_layer| by wrapping
-// |io_surface| in a CVPixelBuffer. This will increase the in-use count
-// of and retain |io_surface| until it is no longer being displayed.
-bool AVSampleBufferDisplayLayerEnqueueIOSurface(
+// This will enqueue |io_surface| to be drawn by |av_layer|. This will
+// retain |cv_pixel_buffer| until it is no longer being displayed.
+bool AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(
     AVSampleBufferDisplayLayer* av_layer,
-    IOSurfaceRef io_surface) {
+    CVPixelBufferRef cv_pixel_buffer) {
   OSStatus os_status = noErr;
-  CVReturn cv_return = kCVReturnSuccess;
-
-  base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
-  cv_return = CVPixelBufferCreateWithIOSurface(
-      nullptr, io_surface, nullptr, cv_pixel_buffer.InitializeInto());
-  if (cv_return != kCVReturnSuccess) {
-    LOG(ERROR) << "CVPixelBufferCreateWithIOSurface failed with " << cv_return;
-    return false;
-  }
 
   base::ScopedCFTypeRef<CMVideoFormatDescriptionRef> video_info;
   os_status = CMVideoFormatDescriptionCreateForImageBuffer(
       nullptr, cv_pixel_buffer, video_info.InitializeInto());
   if (os_status != noErr) {
     LOG(ERROR) << "CMVideoFormatDescriptionCreateForImageBuffer failed with "
                << os_status;
     return false;
   }
 
@@ skipping 31 matching lines @@
     return false;
   }
   CFDictionarySetValue(attachments_dictionary,
                        kCMSampleAttachmentKey_DisplayImmediately,
                        kCFBooleanTrue);
 
   [av_layer enqueueSampleBuffer:sample_buffer];
   return true;
 }
 
+// This will enqueue |io_surface| to be drawn by |av_layer| by wrapping
+// |io_surface| in a CVPixelBuffer. This will increase the in-use count
+// of and retain |io_surface| until it is no longer being displayed.
+bool AVSampleBufferDisplayLayerEnqueueIOSurface(
+    AVSampleBufferDisplayLayer* av_layer,
+    IOSurfaceRef io_surface) {
+  CVReturn cv_return = kCVReturnSuccess;
+
+  base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer;
+  cv_return = CVPixelBufferCreateWithIOSurface(
+      nullptr, io_surface, nullptr, cv_pixel_buffer.InitializeInto());
+  if (cv_return != kCVReturnSuccess) {
+    LOG(ERROR) << "CVPixelBufferCreateWithIOSurface failed with " << cv_return;
+    return false;
+  }
+
+  return AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(av_layer,
+                                                        cv_pixel_buffer);
+}
+
 }  // 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,
+    base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
   // Excessive logging to debug white screens (crbug.com/583805).
   // TODO(ccameron): change this back to a DLOG.
   if (has_committed_) {
     LOG(ERROR) << "ScheduleCALayer called after CommitScheduledCALayers.";
     return false;
   }
   return root_layer_.AddContentLayer(is_clipped, clip_rect, sorting_context_id,
-                                     transform, io_surface, contents_rect, rect,
-                                     background_color, edge_aa_mask, opacity);
+                                     transform, io_surface, cv_pixel_buffer,
+                                     contents_rect, rect, background_color,
+                                     edge_aa_mask, opacity);
 }
 
 void CALayerTree::CommitScheduledCALayers(CALayer* superlayer,
                                           std::unique_ptr<CALayerTree> old_tree,
                                           float scale_factor) {
   TRACE_EVENT0("gpu", "CALayerTree::CommitScheduledCALayers");
   RootLayer* old_root_layer = nullptr;
   if (old_tree) {
     DCHECK(old_tree->has_committed_);
     if (old_tree->scale_factor_ == scale_factor)
@@ skipping 55 matching lines @@
       ca_layer(layer.ca_layer) {
   layer.ca_layer.reset();
 }
 
 CALayerTree::TransformLayer::~TransformLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
 CALayerTree::ContentLayer::ContentLayer(
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
+    base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity)
     : io_surface(io_surface),
+      cv_pixel_buffer(cv_pixel_buffer),
       contents_rect(contents_rect),
       rect(rect),
       background_color(background_color),
       ca_edge_aa_mask(0),
       opacity(opacity) {
   // Because the root layer has setGeometryFlipped:YES, there is some ambiguity
   // about what exactly top and bottom mean. This ambiguity is resolved in
   // different ways for solid color CALayers and for CALayers that have content
   // (surprise!). For CALayers with IOSurface content, the top edge in the AA
   // mask refers to what appears as the bottom edge on-screen. For CALayers
@@ skipping 14 matching lines @@
       ca_edge_aa_mask |= kCALayerTopEdge;
     if (edge_aa_mask & GL_CA_LAYER_EDGE_BOTTOM_CHROMIUM)
       ca_edge_aa_mask |= kCALayerBottomEdge;
   }
 
   // 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)) {
-    // Leave AVFoundation disabled for now while crashing and flashing bugs are
-    // being investigated.
-    // https://crbug.com/598243, https://crbug.com/598388
-    use_av_layer = false;
+    // Enable only for hardware decoded frames, to see if flashing bugs are
+    // particular to software IOSurfaces.
+    // https://crbug.com/598269
+    if (cv_pixel_buffer)
+      use_av_layer = true;
   }
 }
 
 CALayerTree::ContentLayer::ContentLayer(ContentLayer&& layer)
     : io_surface(layer.io_surface),
+      cv_pixel_buffer(layer.cv_pixel_buffer),
       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(std::move(layer.ca_layer)),
       av_layer(std::move(layer.av_layer)),
       use_av_layer(layer.use_av_layer) {
   DCHECK(!layer.ca_layer);
   DCHECK(!layer.av_layer);
 }
 
 CALayerTree::ContentLayer::~ContentLayer() {
   [ca_layer removeFromSuperlayer];
 }
 
 bool CALayerTree::RootLayer::AddContentLayer(
     bool is_clipped,
     const gfx::Rect& clip_rect,
     unsigned sorting_context_id,
     const gfx::Transform& transform,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
+    base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
   bool needs_new_clip_and_sorting_layer = true;
 
   // In sorting_context_id 0, all quads are listed in back-to-front order.
   // This is accomplished by having the CALayers be siblings of each other.
   // If a quad has a 3D transform, it is necessary to put it in its own sorting
@@ skipping 21 matching lines @@
         current_layer.sorting_context_id == sorting_context_id) {
       needs_new_clip_and_sorting_layer = false;
     }
   }
   if (needs_new_clip_and_sorting_layer) {
     clip_and_sorting_layers.push_back(
         ClipAndSortingLayer(is_clipped, clip_rect, sorting_context_id,
                             is_singleton_sorting_context));
   }
   clip_and_sorting_layers.back().AddContentLayer(
-      transform, io_surface, contents_rect, rect, background_color,
-      edge_aa_mask, opacity);
+      transform, io_surface, cv_pixel_buffer, contents_rect, rect,
+      background_color, edge_aa_mask, opacity);
   return true;
 }
 
 void CALayerTree::ClipAndSortingLayer::AddContentLayer(
     const gfx::Transform& transform,
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
+    base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
   bool needs_new_transform_layer = true;
   if (!transform_layers.empty()) {
     const TransformLayer& current_layer = transform_layers.back();
     if (current_layer.transform == transform)
       needs_new_transform_layer = false;
   }
   if (needs_new_transform_layer)
     transform_layers.push_back(TransformLayer(transform));
-  transform_layers.back().AddContentLayer(
-      io_surface, contents_rect, rect, background_color, edge_aa_mask, opacity);
+  transform_layers.back().AddContentLayer(io_surface, cv_pixel_buffer,
+                                          contents_rect, rect, background_color,
+                                          edge_aa_mask, opacity);
 }
 
 void CALayerTree::TransformLayer::AddContentLayer(
     base::ScopedCFTypeRef<IOSurfaceRef> io_surface,
+    base::ScopedCFTypeRef<CVPixelBufferRef> cv_pixel_buffer,
     const gfx::RectF& contents_rect,
     const gfx::Rect& rect,
     unsigned background_color,
     unsigned edge_aa_mask,
     float opacity) {
-  content_layers.push_back(ContentLayer(io_surface, contents_rect, rect,
-                                        background_color, edge_aa_mask,
-                                        opacity));
+  content_layers.push_back(ContentLayer(io_surface, cv_pixel_buffer,
+                                        contents_rect, rect, background_color,
+                                        edge_aa_mask, opacity));
 }
 
 void CALayerTree::RootLayer::CommitToCA(CALayer* superlayer,
                                         RootLayer* old_layer,
                                         float scale_factor) {
   if (old_layer) {
     DCHECK(old_layer->ca_layer);
     std::swap(ca_layer, old_layer->ca_layer);
   } else {
     ca_layer.reset([[CALayer alloc] init]);
@@ skipping 110 matching lines @@
   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 && 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 = old_layer->io_surface != io_surface ||
+                      old_layer->cv_pixel_buffer != cv_pixel_buffer;
     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 {
     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]);
     }
     [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 (use_av_layer) {
-    if (update_contents)
-      AVSampleBufferDisplayLayerEnqueueIOSurface(av_layer, io_surface);
+    if (update_contents) {
+      if (cv_pixel_buffer) {
+        AVSampleBufferDisplayLayerEnqueueCVPixelBuffer(av_layer,
+                                                       cv_pixel_buffer);
+      } else {
+        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)
       [ca_layer setContentsRect:contents_rect.ToCGRect()];
   }
   if (update_rect) {
@@ skipping 33 matching lines @@
     } 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 ui