ozone: Create GbmBuffers from fourcc formats and gbm flags.

ui/ozone/platform/drm/gpu/drm_thread.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 "ui/ozone/platform/drm/gpu/drm_thread.h"
 
+#include <gbm.h>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "services/service_manager/public/cpp/connection.h"
+#include "ui/ozone/platform/drm/common/drm_util.h"
 #include "ui/ozone/platform/drm/gpu/drm_buffer.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_generator.h"
 #include "ui/ozone/platform/drm/gpu/drm_device_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_gpu_display_manager.h"
 #include "ui/ozone/platform/drm/gpu/drm_window.h"
 #include "ui/ozone/platform/drm/gpu/drm_window_proxy.h"
 #include "ui/ozone/platform/drm/gpu/gbm_buffer.h"
 #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/proxy_helpers.h"
 #include "ui/ozone/platform/drm/gpu/screen_manager.h"
 #include "ui/ozone/public/ozone_switches.h"
 
 namespace ui {
 
 namespace {
 
 class GbmBufferGenerator : public ScanoutBufferGenerator {
  public:
   GbmBufferGenerator() {}
   ~GbmBufferGenerator() override {}
 
   // ScanoutBufferGenerator:
   scoped_refptr<ScanoutBuffer> Create(const scoped_refptr<DrmDevice>& drm,
-                                      gfx::BufferFormat format,
+                                      uint32_t format,
                                       const gfx::Size& size) override {
     scoped_refptr<GbmDevice> gbm(static_cast<GbmDevice*>(drm.get()));
     return GbmBuffer::CreateBuffer(gbm, format, size,
-                                   gfx::BufferUsage::SCANOUT);
+                                   GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR);

[tfiga, 2016/12/06 06:16:32]

Why GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR? First of all, GBM_BO_USE_RENDERING
should be necessary for the GPU to actually write anything to this buffer. Then
some platforms (e.g. Intel) can actually scan out of tiled buffers, which is a
significant performance optimization, so forcing linear doesn't make much sense.

[Daniele Castagna, 2016/12/06 06:31:01]

The GPU is not writing to this buffer. We're mapping it and writing to it via SW
skia.

I don't think we care about performance in this case, this allocation is for
buffers that are used only for modesetting after we change the display mode.

[tfiga, 2016/12/06 06:50:57]

Acknowledged.

[marcheu1, 2016/12/13 00:07:06]

This is still wrong. You can't allocate a gem BO and expect to be able to map it
like a dumb buffer since these are two different things. There are two possible
ways to make this consistent:

1. allocate an actual dumb buffer with DRM_IOCTL_MODE_CREATE_DUMB (not through
gbm), then map it like a dumb buffer (which is what the code currently does).

2. allocate a GBM buffer with the LINEAR flag. In theory the LINEAR flag is not
needed because gbm_bo_map() gives you a linear view, except on Tegra where
that's not working because nvidia didn't implement it, and on Kevin where that
might not work because we don't know how to decompress AFBC. You need to then
change the code which maps the buffer to use gbm_bo_map() instead of
DRM_IOCTL_MODE_MAP_DUMB.

[Daniele Castagna, 2016/12/13 02:28:59]

As discussed offline, let's start landing crrev.com/2568243004 as a temporary
fix for the regression described in crbug.com/673026

   }
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(GbmBufferGenerator);
 };
 
 class GbmDeviceGenerator : public DrmDeviceGenerator {
  public:
   GbmDeviceGenerator(bool use_atomic) : use_atomic_(use_atomic) {}
   ~GbmDeviceGenerator() override {}
@@ skipping 48 matching lines @@
 }
 
 void DrmThread::CreateBuffer(gfx::AcceleratedWidget widget,
                              const gfx::Size& size,
                              gfx::BufferFormat format,
                              gfx::BufferUsage usage,
                              scoped_refptr<GbmBuffer>* buffer) {
   scoped_refptr<GbmDevice> gbm =
       static_cast<GbmDevice*>(device_manager_->GetDrmDevice(widget).get());
   DCHECK(gbm);
-  *buffer = GbmBuffer::CreateBuffer(gbm, format, size, usage);
+
+  uint32_t 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;
+  }
+
+  *buffer = GbmBuffer::CreateBuffer(
+      gbm, ui::GetFourCCFormatFromBufferFormat(format), size, flags);
 }
 
 void DrmThread::CreateBufferFromFds(
     gfx::AcceleratedWidget widget,
     const gfx::Size& size,
     gfx::BufferFormat format,
     std::vector<base::ScopedFD>&& fds,
     const std::vector<gfx::NativePixmapPlane>& planes,
     scoped_refptr<GbmBuffer>* buffer) {
   scoped_refptr<GbmDevice> gbm =
       static_cast<GbmDevice*>(device_manager_->GetDrmDevice(widget).get());
   DCHECK(gbm);
-  *buffer =
-      GbmBuffer::CreateBufferFromFds(gbm, format, size, std::move(fds), planes);
+  *buffer = GbmBuffer::CreateBufferFromFds(
+      gbm, ui::GetFourCCFormatFromBufferFormat(format), size, std::move(fds),
+      planes);
 }
 
 void DrmThread::GetScanoutFormats(
     gfx::AcceleratedWidget widget,
     std::vector<gfx::BufferFormat>* scanout_formats) {
   display_manager_->GetScanoutFormats(widget, scanout_formats);
 }
 
 void DrmThread::SchedulePageFlip(gfx::AcceleratedWidget widget,
                                  const std::vector<OverlayPlane>& planes,
@@ skipping 119 matching lines @@
                                        correction_matrix);
 }
 
 // DrmThread requires a BindingSet instead of a simple Binding because it will
 // be used from multiple threads in multiple processes.
 void DrmThread::AddBinding(ozone::mojom::DeviceCursorRequest request) {
   bindings_.AddBinding(this, std::move(request));
 }
 
 }  // namespace ui