Add format modifier IDs for EGL_EXT_image_dma_buf_import extension

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 14 matching lines @@
 #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,
                      std::vector<base::ScopedFD>&& fds,
                      const gfx::Size& size,
-                     const std::vector<int>& strides,
-                     const std::vector<int>& offsets)
+                     const std::vector<gfx::GbmBufferPlane>&& planes)
     : GbmBufferBase(gbm, bo, format, usage),
       format_(format),
       usage_(usage),
       fds_(std::move(fds)),
       size_(size),
-      strides_(strides),
-      offsets_(offsets) {}
+      planes_(std::move(planes)) {}
 
 GbmBuffer::~GbmBuffer() {
   if (bo())
     gbm_bo_destroy(bo());
 }
 
 bool GbmBuffer::AreFdsValid() const {
   if (fds_.empty())
     return false;
 
   for (const auto& fd : fds_) {
     if (fd.get() == -1)
       return false;
   }
   return true;
 }
 
 size_t GbmBuffer::GetFdCount() const {
   return fds_.size();
 }
 
 int GbmBuffer::GetFd(size_t plane) const {

[Daniele Castagna, 2016/06/15 03:50:20]

I'd say |plane| here as parameter is confusing. Should we change this to index?

[vinceh, 2016/06/15 04:35:18]

Yes, that's confusing. Will change it to index.

   DCHECK_LT(plane, fds_.size());
   return fds_[plane].get();
 }
 
 int GbmBuffer::GetStride(size_t plane) const {
-  DCHECK_LT(plane, strides_.size());
-  return strides_[plane];
+  DCHECK_LT(plane, planes_.size());
+  return planes_[plane].stride;
 }
 
 int GbmBuffer::GetOffset(size_t plane) const {
-  DCHECK_LT(plane, offsets_.size());
-  return offsets_[plane];
+  DCHECK_LT(plane, planes_.size());
+  return planes_[plane].offset;
+}
+
+uint64_t GbmBuffer::GetFormatModifier(size_t plane) const {
+  DCHECK_LT(plane, planes_.size());
+  return planes_[plane].modifier;
 }
 
 // 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(
@@ skipping 25 matching lines @@
   // 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_fd(bo));
   if (!fd.is_valid()) {
     PLOG(ERROR) << "Failed to export buffer to dma_buf";
     gbm_bo_destroy(bo);
     return nullptr;
   }
   std::vector<base::ScopedFD> fds;
   fds.emplace_back(std::move(fd));
-  std::vector<int> strides;
-  strides.push_back(gbm_bo_get_stride(bo));
-  std::vector<int> offsets;
-  offsets.push_back(gbm_bo_get_plane_offset(bo, 0));
+  std::vector<gfx::GbmBufferPlane> planes;
+  planes.emplace_back(gbm_bo_get_stride(bo), gbm_bo_get_plane_offset(bo, 0),
+                      gbm_bo_get_format_modifier(bo));
   scoped_refptr<GbmBuffer> buffer(new GbmBuffer(
-      gbm, bo, format, usage, std::move(fds), size, strides, offsets));
+      gbm, bo, format, usage, std::move(fds), size, std::move(planes)));
   if (usage == gfx::BufferUsage::SCANOUT && !buffer->GetFramebufferId())
     return nullptr;
 
   return buffer;
 }
 
 // static
 scoped_refptr<GbmBuffer> GbmBuffer::CreateBufferFromFds(
     const scoped_refptr<GbmDevice>& gbm,
     gfx::BufferFormat format,
     const gfx::Size& size,
     std::vector<base::ScopedFD>&& fds,
-    const std::vector<int>& strides,
-    const std::vector<int>& offsets) {
+    const std::vector<gfx::GbmBufferPlane>&& planes) {
   TRACE_EVENT2("drm", "GbmBuffer::CreateBufferFromFD", "device",
                gbm->device_path().value(), "size", size.ToString());
-  DCHECK_EQ(fds.size(), strides.size());
+  DCHECK_EQ(fds.size(), planes.size());
   // TODO(reveman): Use gbm_bo_import after making buffers survive
   // GPU process crashes. crbug.com/597932
   return make_scoped_refptr(
       new GbmBuffer(gbm, nullptr, format, gfx::BufferUsage::GPU_READ,
-                    std::move(fds), size, strides, offsets));
+                    std::move(fds), size, std::move(planes)));
 }
 
 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) {
     // 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 */));
     }
-    handle.strides_and_offsets.emplace_back(buffer_->GetStride(i),
-                                            buffer_->GetOffset(i));
+    handle.planes.emplace_back(buffer_->GetStride(i), buffer_->GetOffset(i),
+                               buffer_->GetFormatModifier(i));
   }
   return handle;
 }
 
 GbmPixmap::~GbmPixmap() {
 }
 
 void* GbmPixmap::GetEGLClientBuffer() const {
   return nullptr;
 }
@@ skipping 11 matching lines @@
 }
 
 int GbmPixmap::GetDmaBufPitch(size_t plane) const {
   return buffer_->GetStride(plane);
 }
 
 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();
 }
 
 gfx::Size GbmPixmap::GetBufferSize() const {
   return buffer_->GetSize();
 }
 
 bool GbmPixmap::ScheduleOverlayPlane(gfx::AcceleratedWidget widget,
                                      int plane_z_order,
@@ skipping 37 matching lines @@
   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