Add YUV_420_BIPLANAR to gfx::BufferFormat.

content/common/gpu/gpu_memory_buffer_factory_io_surface.cc

 // Copyright 2014 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/gpu_memory_buffer_factory_io_surface.h"
 
 #include <CoreFoundation/CoreFoundation.h>
 
 #include <vector>
 
 #include "base/logging.h"
+#include "content/common/gpu/client/gpu_memory_buffer_impl.h"
 #include "content/common/mac/io_surface_manager.h"
+#include "ui/gfx/buffer_format_util.h"
 #include "ui/gl/gl_image_io_surface.h"
 
 namespace content {
 namespace {
 
 void AddIntegerValue(CFMutableDictionaryRef dictionary,
                      const CFStringRef key,
                      int32 value) {
   base::ScopedCFTypeRef<CFNumberRef> number(
       CFNumberCreate(NULL, kCFNumberSInt32Type, &value));
   CFDictionaryAddValue(dictionary, key, number.get());
 }
 
 int32 BytesPerPixel(gfx::BufferFormat format) {
   switch (format) {
     case gfx::BufferFormat::R_8:
+    case gfx::BufferFormat::YUV_420_BIPLANAR:
       return 1;
     case gfx::BufferFormat::BGRA_8888:
       return 4;
     case gfx::BufferFormat::ATC:
     case gfx::BufferFormat::ATCIA:
     case gfx::BufferFormat::DXT1:
     case gfx::BufferFormat::DXT5:
     case gfx::BufferFormat::ETC1:
     case gfx::BufferFormat::RGBA_4444:
     case gfx::BufferFormat::RGBA_8888:
     case gfx::BufferFormat::RGBX_8888:
     case gfx::BufferFormat::YUV_420:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 int32 PixelFormat(gfx::BufferFormat format) {
   switch (format) {
     case gfx::BufferFormat::R_8:
       return 'L008';
     case gfx::BufferFormat::BGRA_8888:
       return 'BGRA';
+    case gfx::BufferFormat::YUV_420_BIPLANAR:
+      return '420v';
     case gfx::BufferFormat::ATC:
     case gfx::BufferFormat::ATCIA:
     case gfx::BufferFormat::DXT1:
     case gfx::BufferFormat::DXT5:
     case gfx::BufferFormat::ETC1:
     case gfx::BufferFormat::RGBA_4444:
     case gfx::BufferFormat::RGBA_8888:
     case gfx::BufferFormat::RGBX_8888:
     case gfx::BufferFormat::YUV_420:
       NOTREACHED();
       return 0;
   }
 
   NOTREACHED();
   return 0;
 }
 
 const GpuMemoryBufferFactory::Configuration kSupportedConfigurations[] = {
     {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::SCANOUT},
     {gfx::BufferFormat::R_8, gfx::BufferUsage::PERSISTENT_MAP},
     {gfx::BufferFormat::R_8, gfx::BufferUsage::MAP},
     {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::PERSISTENT_MAP},
-    {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::MAP}};
+    {gfx::BufferFormat::BGRA_8888, gfx::BufferUsage::MAP},
+    {gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferUsage::MAP},
+    {gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferUsage::PERSISTENT_MAP},
+};
 
 }  // namespace
 
 GpuMemoryBufferFactoryIOSurface::GpuMemoryBufferFactoryIOSurface() {
 }
 
 GpuMemoryBufferFactoryIOSurface::~GpuMemoryBufferFactoryIOSurface() {
 }
 
 // static
@@ skipping 16 matching lines @@
 }
 
 gfx::GpuMemoryBufferHandle
 GpuMemoryBufferFactoryIOSurface::CreateGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     const gfx::Size& size,
     gfx::BufferFormat format,
     gfx::BufferUsage usage,
     int client_id,
     gfx::PluginWindowHandle surface_handle) {
-  base::ScopedCFTypeRef<CFMutableDictionaryRef> properties;
-  properties.reset(CFDictionaryCreateMutable(kCFAllocatorDefault,
-                                             0,
-                                             &kCFTypeDictionaryKeyCallBacks,
-                                             &kCFTypeDictionaryValueCallBacks));
+  base::ScopedCFTypeRef<CFMutableDictionaryRef> properties(
+      CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                &kCFTypeDictionaryKeyCallBacks,
+                                &kCFTypeDictionaryValueCallBacks));
   AddIntegerValue(properties, kIOSurfaceWidth, size.width());
   AddIntegerValue(properties, kIOSurfaceHeight, size.height());
-  AddIntegerValue(properties, kIOSurfaceBytesPerElement, BytesPerPixel(format));
   AddIntegerValue(properties, kIOSurfacePixelFormat, PixelFormat(format));
 
+  size_t num_planes = gfx::NumberOfPlanesForBufferFormat(format);
+  DCHECK_GT(num_planes, 0u);
+  if (num_planes == 1) {

[reveman, 2015/08/11 08:20:08]

This is unfortunate. What happens if we remove this if statement? Single plane
formats don't work unless kIOSurfaceBytesPerElement is set?

In that case, I'd prefer if we handled this explicitly using a large "switch
(format)" statement to make it very clear what formats need the plane info and
what formats don't.

[Andre, 2015/08/11 18:15:44]

Done.
I removed the if statement, and it seems to work just fine.

+    AddIntegerValue(
+        properties, kIOSurfaceBytesPerElement, BytesPerPixel(format));
+  } else {
+    base::ScopedCFTypeRef<CFMutableArrayRef> planes(CFArrayCreateMutable(
+        kCFAllocatorDefault, num_planes, &kCFTypeArrayCallBacks));
+
+    for (size_t plane = 0; plane < num_planes; ++plane) {
+      size_t factor = GpuMemoryBufferImpl::SubsamplingFactor(format, plane);
+      gfx::Size plane_size(size.width() / factor, size.height() / factor);
+      size_t row_size;
+      bool valid_row_size = GpuMemoryBufferImpl::RowSizeInBytes(
+                                size.width(), format, plane, &row_size);
+      DCHECK(valid_row_size);
+
+      base::ScopedCFTypeRef<CFMutableDictionaryRef> plane_info(
+          CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
+                                    &kCFTypeDictionaryKeyCallBacks,
+                                    &kCFTypeDictionaryValueCallBacks));
+      AddIntegerValue(plane_info, kIOSurfacePlaneWidth, plane_size.width());
+      AddIntegerValue(plane_info, kIOSurfacePlaneHeight, plane_size.height());
+      AddIntegerValue(plane_info, kIOSurfacePlaneBytesPerElement,
+                      row_size / plane_size.width());

[reveman, 2015/08/11 08:20:08]

Instead of using RowSizeInBytes here, can we replace the BytesPerPixel function
with a BytesPerElement function that takes the plane index as a parameter?

[Andre, 2015/08/11 18:15:44]

Great idea, done.

+
+      CFArrayAppendValue(planes, plane_info);
+    }
+
+    CFDictionaryAddValue(properties, kIOSurfacePlaneInfo, planes);
+  }
+
   base::ScopedCFTypeRef<IOSurfaceRef> io_surface(IOSurfaceCreate(properties));
   if (!io_surface)
     return gfx::GpuMemoryBufferHandle();
 
   if (!IOSurfaceManager::GetInstance()->RegisterIOSurface(id, client_id,
                                                           io_surface)) {
     return gfx::GpuMemoryBufferHandle();
   }
 
   {
@@ skipping 45 matching lines @@
 
   scoped_refptr<gfx::GLImageIOSurface> image(
       new gfx::GLImageIOSurface(size, internalformat));
   if (!image->Initialize(it->second.get(), format))
     return scoped_refptr<gfx::GLImage>();
 
   return image;
 }
 
 }  // namespace content