exo: Add support for importing YVU_420 buffers.

components/exo/wayland/server.cc

 // Copyright 2015 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 "components/exo/wayland/server.h"
 
 #include <grp.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 38 matching lines @@
 #include "components/exo/surface.h"
 #include "components/exo/touch.h"
 #include "components/exo/touch_delegate.h"
 #include "ipc/unix_domain_socket_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/screen.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
+#include "ui/gfx/buffer_format_util.h"
+#include "ui/gfx/buffer_types.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_observer.h"
 #include "ui/wm/public/activation_change_observer.h"
 #include "ui/wm/public/activation_client.h"
 
 #if defined(USE_OZONE)
 #include <drm_fourcc.h>
 #include <linux-dmabuf-unstable-v1-server-protocol.h>
 #include <wayland-drm-server-protocol.h>
 #endif
@@ skipping 374 matching lines @@
 // wl_drm_interface:
 
 const struct drm_supported_format {
   uint32_t drm_format;
   gfx::BufferFormat buffer_format;
 } drm_supported_formats[] = {
     {WL_DRM_FORMAT_RGB565, gfx::BufferFormat::BGR_565},
     {WL_DRM_FORMAT_XBGR8888, gfx::BufferFormat::RGBX_8888},
     {WL_DRM_FORMAT_ABGR8888, gfx::BufferFormat::RGBA_8888},
     {WL_DRM_FORMAT_XRGB8888, gfx::BufferFormat::BGRX_8888},
-    {WL_DRM_FORMAT_ARGB8888, gfx::BufferFormat::BGRA_8888}};
+    {WL_DRM_FORMAT_ARGB8888, gfx::BufferFormat::BGRA_8888},
+    {WL_DRM_FORMAT_YVU420, gfx::BufferFormat::YVU_420}};
 
 void drm_authenticate(wl_client* client, wl_resource* resource, uint32_t id) {
   wl_drm_send_authenticated(resource);
 }
 
 void drm_create_buffer(wl_client* client,
                        wl_resource* resource,
                        uint32_t id,
                        uint32_t name,
                        int32_t width,
@@ skipping 40 matching lines @@
                    [format](const drm_supported_format& supported_format) {
                      return supported_format.drm_format == format;
                    });
   if (supported_format ==
       (drm_supported_formats + arraysize(drm_supported_formats))) {
     wl_resource_post_error(resource, WL_DRM_ERROR_INVALID_FORMAT,
                            "invalid format 0x%x", format);
     return;
   }
 
+  std::vector<int> strides{stride0, stride1, stride2};
+  std::vector<int> offsets{offset0, offset1, offset2};
+  std::vector<base::ScopedFD> fds;
+
+  int planes =
+      gfx::NumberOfPlanesForBufferFormat(supported_format->buffer_format);
+  strides.resize(planes);
+  offsets.resize(planes);
+  fds.push_back(base::ScopedFD(name));
+
   std::unique_ptr<Buffer> buffer =
       GetUserDataAs<Display>(resource)->CreateLinuxDMABufBuffer(
-          base::ScopedFD(name), gfx::Size(width, height),
-          supported_format->buffer_format, stride0);
+          gfx::Size(width, height), supported_format->buffer_format, strides,
+          offsets, std::move(fds));
   if (!buffer) {
     wl_resource_post_no_memory(resource);
     return;
   }
 
   wl_resource* buffer_resource =
       wl_resource_create(client, &wl_buffer_interface, 1, id);
 
   buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
                                           base::Unretained(buffer_resource)));
@@ skipping 24 matching lines @@
 // linux_buffer_params_interface:
 
 const struct dmabuf_supported_format {
   uint32_t dmabuf_format;
   gfx::BufferFormat buffer_format;
 } dmabuf_supported_formats[] = {
     {DRM_FORMAT_RGB565, gfx::BufferFormat::BGR_565},
     {DRM_FORMAT_XBGR8888, gfx::BufferFormat::RGBX_8888},
     {DRM_FORMAT_ABGR8888, gfx::BufferFormat::RGBA_8888},
     {DRM_FORMAT_XRGB8888, gfx::BufferFormat::BGRX_8888},
-    {DRM_FORMAT_ARGB8888, gfx::BufferFormat::BGRA_8888}};
+    {DRM_FORMAT_ARGB8888, gfx::BufferFormat::BGRA_8888},
+    {DRM_FORMAT_YVU420, gfx::BufferFormat::YVU_420}};
 
 struct LinuxBufferParams {
-  explicit LinuxBufferParams(Display* display)
-      : display(display), stride(0), offset(0) {}
+  struct Plane {
+    base::ScopedFD fd;
+    uint32_t stride;
+    uint32_t offset;
+  };
+
+  explicit LinuxBufferParams(Display* display) : display(display) {}
 
   Display* const display;
-  base::ScopedFD fd;
-  uint32_t stride;
-  uint32_t offset;
+  std::map<uint32_t, Plane> planes;
 };
 
 void linux_buffer_params_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 void linux_buffer_params_add(wl_client* client,
                              wl_resource* resource,
                              int32_t fd,
                              uint32_t plane_idx,
                              uint32_t offset,
                              uint32_t stride,
                              uint32_t modifier_hi,
                              uint32_t modifier_lo) {
-  if (plane_idx) {
-    wl_resource_post_error(resource, ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX,
-                           "plane_idx too large");
-    return;
-  }
-
   LinuxBufferParams* linux_buffer_params =
       GetUserDataAs<LinuxBufferParams>(resource);
-  if (linux_buffer_params->fd.is_valid()) {
+
+  LinuxBufferParams::Plane plane{base::ScopedFD(fd), stride, offset};
+
+  const auto& inserted = linux_buffer_params->planes.insert(
+      std::pair<uint32_t, LinuxBufferParams::Plane>(plane_idx,
+                                                    std::move(plane)));
+  if (!inserted.second) {  // The plane was already there.
     wl_resource_post_error(resource, ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_SET,
                            "plane already set");
     return;
   }
-
-  linux_buffer_params->fd.reset(fd);
-  linux_buffer_params->stride = stride;
-  linux_buffer_params->offset = offset;
 }
 
 void linux_buffer_params_create(wl_client* client,
                                 wl_resource* resource,
                                 int32_t width,
                                 int32_t height,
                                 uint32_t format,
                                 uint32_t flags) {
   if (width <= 0 || height <= 0) {
     wl_resource_post_error(resource,
@@ skipping 17 matching lines @@
   if (flags & (ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_Y_INVERT |
                ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_INTERLACED)) {
     wl_resource_post_error(resource,
                            ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE,
                            "flags not supported");
     return;
   }
 
   LinuxBufferParams* linux_buffer_params =
       GetUserDataAs<LinuxBufferParams>(resource);
-  if (linux_buffer_params->offset) {
-    wl_resource_post_error(resource,
-                           ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_OUT_OF_BOUNDS,
-                           "offset not supported");
+
+  size_t num_planes =
+      gfx::NumberOfPlanesForBufferFormat(supported_format->buffer_format);
+
+  if (linux_buffer_params->planes.size() != num_planes) {
+    wl_resource_post_error(resource, ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX,
+                           "plane idx out of bounds");
     return;
   }
 
+  std::vector<int> strides;
+  std::vector<int> offsets;
+  std::vector<base::ScopedFD> fds;
+
+  for (uint32_t i = 0; i < num_planes; ++i) {
+    auto plane_it = linux_buffer_params->planes.find(i);
+    if (plane_it == linux_buffer_params->planes.end()) {
+      wl_resource_post_error(resource,
+                             ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE,
+                             "missing a plane");
+      return;
+    }
+    LinuxBufferParams::Plane& plane = plane_it->second;
+    strides.push_back(plane.stride);
+    offsets.push_back(plane.offset);
+    if (plane.fd.is_valid())
+      fds.push_back(std::move(plane.fd));
+  }
+
   std::unique_ptr<Buffer> buffer =
       linux_buffer_params->display->CreateLinuxDMABufBuffer(
-          std::move(linux_buffer_params->fd), gfx::Size(width, height),
-          supported_format->buffer_format, linux_buffer_params->stride);
+          gfx::Size(width, height), supported_format->buffer_format, strides,
+          offsets, std::move(fds));
   if (!buffer) {
     zwp_linux_buffer_params_v1_send_failed(resource);
     return;
   }
 
   wl_resource* buffer_resource =
       wl_resource_create(client, &wl_buffer_interface, 1, 0);
 
   buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
                                           base::Unretained(buffer_resource)));
@@ skipping 1916 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo