ozone: Create GbmBuffers from fourcc formats and gbm flags.

ui/ozone/platform/drm/gpu/gbm_buffer.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 "ui/ozone/platform/drm/gpu/gbm_buffer.h"
 
 #include <drm.h>
 #include <fcntl.h>
 #include <gbm.h>
 #include <xf86drm.h>
@@ skipping 10 matching lines @@
 #include "ui/ozone/platform/drm/gpu/gbm_device.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surface_factory.h"
 #include "ui/ozone/platform/drm/gpu/gbm_surfaceless.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 
 namespace ui {
 
 GbmBuffer::GbmBuffer(const scoped_refptr<GbmDevice>& gbm,
                      gbm_bo* bo,
-                     gfx::BufferFormat format,
-                     gfx::BufferUsage usage,
+                     uint32_t format,
+                     uint32_t flags,
                      std::vector<base::ScopedFD>&& fds,
                      const gfx::Size& size,
                      const std::vector<gfx::NativePixmapPlane>&& planes)
-    : GbmBufferBase(gbm, bo, format, usage),
+    : GbmBufferBase(gbm, bo, format, flags),
       format_(format),
-      usage_(usage),
+      flags_(flags),
       fds_(std::move(fds)),
       size_(size),
       planes_(std::move(planes)) {}
 
 GbmBuffer::~GbmBuffer() {
   if (bo())
     gbm_bo_destroy(bo());
 }
 
 bool GbmBuffer::AreFdsValid() const {
@@ skipping 38 matching lines @@
 
 // TODO(reveman): This should not be needed once crbug.com/597932 is fixed,
 // as the size would be queried directly from the underlying bo.
 gfx::Size GbmBuffer::GetSize() const {
   return size_;
 }
 
 // static
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBuffer(
     const scoped_refptr<GbmDevice>& gbm,
-    gfx::BufferFormat format,
+    uint32_t format,
     const gfx::Size& size,
-    gfx::BufferUsage usage) {
+    uint32_t flags) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBuffer", "device",
                gbm->device_path().value(), "size", size.ToString());
 
-  unsigned flags = 0;
-  switch (usage) {
-    case gfx::BufferUsage::GPU_READ:
-      break;
-    case gfx::BufferUsage::SCANOUT:
-      flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING;
-      break;
-    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE:
-    case gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT:
-      flags = GBM_BO_USE_LINEAR;
-      break;
-  }
-
-  gbm_bo* bo = gbm_bo_create(gbm->device(), size.width(), size.height(),
-                             GetFourCCFormatFromBufferFormat(format), flags);
+  gbm_bo* bo =
+      gbm_bo_create(gbm->device(), size.width(), size.height(), format, flags);
   if (!bo)
     return nullptr;
 
   std::vector<base::ScopedFD> fds;
   std::vector<gfx::NativePixmapPlane> planes;
 
-  DCHECK_EQ(gbm_bo_get_num_planes(bo),
-            gfx::NumberOfPlanesForBufferFormat(format));
-  for (size_t i = 0; i < gfx::NumberOfPlanesForBufferFormat(format); ++i) {
+  for (size_t i = 0; i < gbm_bo_get_num_planes(bo); ++i) {
     // The fd returned by gbm_bo_get_fd is not ref-counted and need to be
     // kept open for the lifetime of the buffer.
     base::ScopedFD fd(gbm_bo_get_plane_fd(bo, i));
 
     // TODO(dcastagna): support multiple fds.
     // crbug.com/642410
     if (!i) {
       if (!fd.is_valid()) {
         PLOG(ERROR) << "Failed to export buffer to dma_buf";
         gbm_bo_destroy(bo);
         return nullptr;
       }
       fds.emplace_back(std::move(fd));
     }
 
     planes.emplace_back(
         gbm_bo_get_plane_stride(bo, i), gbm_bo_get_plane_offset(bo, i),
         gbm_bo_get_plane_size(bo, i), gbm_bo_get_plane_format_modifier(bo, i));
   }
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(
-      gbm, bo, format, usage, std::move(fds), size, std::move(planes)));
-  if (usage == gfx::BufferUsage::SCANOUT && !buffer->GetFramebufferId())
+      gbm, bo, format, flags, std::move(fds), size, std::move(planes)));
+  if (flags & GBM_BO_USE_SCANOUT && !buffer->GetFramebufferId())
     return nullptr;
 
   return buffer;
 }
 
 // static
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBufferFromFds(
     const scoped_refptr<GbmDevice>& gbm,
-    gfx::BufferFormat format,
+    uint32_t format,
     const gfx::Size& size,
     std::vector<base::ScopedFD>&& fds,
     const std::vector<gfx::NativePixmapPlane>& planes) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBufferFromFD", "device",
                gbm->device_path().value(), "size", size.ToString());
   DCHECK_LE(fds.size(), planes.size());
   DCHECK_EQ(planes[0].offset, 0);
 
-  uint32_t fourcc_format = GetFourCCFormatFromBufferFormat(format);
-
   // Use scanout if supported.
-  bool use_scanout = gbm_device_is_format_supported(
-                         gbm->device(), fourcc_format,
-                         GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING) &&
-                     (planes.size() == 1);
+  bool use_scanout =
+      gbm_device_is_format_supported(
+          gbm->device(), format, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING) &&
+      (planes.size() == 1);
 
   gbm_bo* bo = nullptr;
   if (use_scanout) {
     struct gbm_import_fd_data fd_data;
     fd_data.fd = fds[0].get();
     fd_data.width = size.width();
     fd_data.height = size.height();
     fd_data.stride = planes[0].stride;
-    fd_data.format = fourcc_format;
+    fd_data.format = format;
 
     // The fd passed to gbm_bo_import is not ref-counted and need to be
     // kept open for the lifetime of the buffer.
     bo = gbm_bo_import(gbm->device(), GBM_BO_IMPORT_FD, &fd_data,
                        GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING);
     if (!bo) {
       LOG(ERROR) << "nullptr returned from gbm_bo_import";
       return nullptr;
     }
   }
 
+  uint32_t flags = GBM_BO_USE_RENDERING;
+  if (use_scanout)
+    flags |= GBM_BO_USE_SCANOUT;
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(
-      gbm, bo, format,
-      use_scanout ? gfx::BufferUsage::SCANOUT : gfx::BufferUsage::GPU_READ,
-      std::move(fds), size, std::move(planes)));
+      gbm, bo, format, flags, std::move(fds), size, std::move(planes)));
   // If scanout support for buffer is expected then make sure we managed to
   // create a framebuffer for it as otherwise using it for scanout will fail.
   if (use_scanout && !buffer->GetFramebufferId())
     return nullptr;
 
   return buffer;
 }
 
 GbmPixmap::GbmPixmap(GbmSurfaceFactory* surface_manager,
                      const scoped_refptr<GbmBuffer>& buffer)
     : surface_manager_(surface_manager), buffer_(buffer) {}
 
 void GbmPixmap::SetProcessingCallback(
     const ProcessingCallback& processing_callback) {
   DCHECK(processing_callback_.is_null());
   processing_callback_ = processing_callback;
 }
 
 gfx::NativePixmapHandle GbmPixmap::ExportHandle() {
   gfx::NativePixmapHandle handle;
-  for (size_t i = 0;
-       i < gfx::NumberOfPlanesForBufferFormat(buffer_->GetFormat()); ++i) {
+  gfx::BufferFormat format =
+      ui::GetBufferFormatFromFourCCFormat(buffer_->GetFormat());
+  // TODO(dcastagna): Use gbm_bo_get_num_planes.
+  for (size_t i = 0; i < gfx::NumberOfPlanesForBufferFormat(format); ++i) {

[dnicoara, 2016/11/30 15:12:01]

Wondering why gbm_bo_get_num_planes() can't be used right now? Especially since
it is being used above in line 111.

[Daniele Castagna, 2016/11/30 18:41:38]

We don't always have a gbm bo pointer. There are some formats that we import but
can't be gbm imported, so no bo for those.

We can use gbm_bo_get_num_planes at line 111 since that is after allocating a
buffer via gbm, and we know for sure we have a bo at that point.

Updated the TODO for clarity.

[dnicoara, 2016/11/30 18:44:15]

Ahh, thank you for clarifying.

     // Some formats (e.g: YVU_420) might have less than one fd per plane.
     if (i < buffer_->GetFdCount()) {
       base::ScopedFD scoped_fd(HANDLE_EINTR(dup(buffer_->GetFd(i))));
       if (!scoped_fd.is_valid()) {
         PLOG(ERROR) << "dup";
         return gfx::NativePixmapHandle();
       }
       handle.fds.emplace_back(
           base::FileDescriptor(scoped_fd.release(), true /* auto_close */));
     }
@@ skipping 29 matching lines @@
 
 int GbmPixmap::GetDmaBufOffset(size_t plane) const {
   return buffer_->GetOffset(plane);
 }
 
 uint64_t GbmPixmap::GetDmaBufModifier(size_t plane) const {
   return buffer_->GetFormatModifier(plane);
 }
 
 gfx::BufferFormat GbmPixmap::GetBufferFormat() const {
-  return buffer_->GetFormat();
+  return ui::GetBufferFormatFromFourCCFormat(buffer_->GetFormat());
 }
 
 gfx::Size GbmPixmap::GetBufferSize() const {
   return buffer_->GetSize();
 }
 
 bool GbmPixmap::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                      int plane_z_order,
                                      gfx::OverlayTransform plane_transform,
                                      const gfx::Rect& display_bounds,
                                      const gfx::RectF& crop_rect) {
-  DCHECK(buffer_->GetUsage() == gfx::BufferUsage::SCANOUT);
+  DCHECK(buffer_->GetFlags() & GBM_BO_USE_SCANOUT);
   OverlayPlane::ProcessBufferCallback processing_callback;
   if (!processing_callback_.is_null())
     processing_callback = base::Bind(&GbmPixmap::ProcessBuffer, this);
 
   surface_manager_->GetSurface(widget)->QueueOverlayPlane(
       OverlayPlane(buffer_, plane_z_order, plane_transform, display_bounds,
                    crop_rect, processing_callback));
 
   return true;
 }
 
 scoped_refptr<ScanoutBuffer> GbmPixmap::ProcessBuffer(const gfx::Size& size,
                                                       uint32_t format) {
   DCHECK(GetBufferSize() != size ||
          buffer_->GetFramebufferPixelFormat() != format);
 
   if (!processed_pixmap_ || size != processed_pixmap_->GetBufferSize() ||
       format != processed_pixmap_->buffer()->GetFramebufferPixelFormat()) {
     // Release any old processed pixmap.
     processed_pixmap_ = nullptr;
-    gfx::BufferFormat buffer_format = GetBufferFormatFromFourCCFormat(format);
-
     scoped_refptr<GbmBuffer> buffer = GbmBuffer::CreateBuffer(
-        buffer_->drm().get(), buffer_format, size, buffer_->GetUsage());
+        buffer_->drm().get(), format, size, buffer_->GetFlags());
     if (!buffer)
       return nullptr;
 
     // ProcessBuffer is called on DrmThread. We could have used
     // CreateNativePixmap to initialize the pixmap, however it posts a
     // synchronous task to DrmThread resulting in a deadlock.
     processed_pixmap_ = new GbmPixmap(surface_manager_, buffer);
   }
 
   DCHECK(!processing_callback_.is_null());
   if (!processing_callback_.Run(this, processed_pixmap_)) {
     LOG(ERROR) << "Failed processing NativePixmap";
     return nullptr;
   }
 
   return processed_pixmap_->buffer();
 }
 
 }  // namespace ui