ozone: Add KMS "rotation" property support.

ui/ozone/platform/drm/gpu/hardware_display_plane_atomic.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/hardware_display_plane_atomic.h"
 
 #include "ui/ozone/platform/drm/gpu/drm_device.h"
 
 namespace ui {
 namespace {
 
 const char* kCrtcPropName = "CRTC_ID";
 const char* kFbPropName = "FB_ID";
 const char* kCrtcXPropName = "CRTC_X";
 const char* kCrtcYPropName = "CRTC_Y";
 const char* kCrtcWPropName = "CRTC_W";
 const char* kCrtcHPropName = "CRTC_H";
 const char* kSrcXPropName = "SRC_X";
 const char* kSrcYPropName = "SRC_Y";
 const char* kSrcWPropName = "SRC_W";
 const char* kSrcHPropName = "SRC_H";
+const char* kRotationPropName = "rotation";
+
+const int kDrmRotate0 = 0;

[dnicoara, 2017/04/11 13:51:06]

Do you know if there's plans to have these in libdrm headers?

[Daniele Castagna, 2017/04/11 20:21:05]

I just asked Kristian and he agreed it should probably be there already.
Currently DRM_ROTATE_0/90 and co. are defined only in drm_crtc.h

For now, I copied those defines here and put them in an #if
!defined(DRM_ROTATE_0), so that once we moved them in libdrm we can get rid of
this copy.

+const int kDrmRotate90 = 1;
+const int kDrmRotate180 = 4;
+const int kDrmRotate270 = 8;
+const int kDrmReflectX = 16;
+const int kDrmReflectY = 32;

[dnicoara, 2017/04/11 13:51:06]

nit: Could these be in hex or as bit shifts?

[Daniele Castagna, 2017/04/11 20:21:05]

Re-used the drm_crtc defines. The bit shifts is now in the switch case in
OverlayTransformToDrmRotationPropertyValue.

+
+uint32_t OverlayTransformToDrmRotationPropertyValue(
+    gfx::OverlayTransform transform) {
+  switch (transform) {
+    case gfx::OVERLAY_TRANSFORM_NONE:
+      return kDrmRotate0;
+    case gfx::OVERLAY_TRANSFORM_FLIP_HORIZONTAL:
+      return kDrmReflectX;
+    case gfx::OVERLAY_TRANSFORM_FLIP_VERTICAL:
+      return kDrmReflectY;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_90:
+      return kDrmRotate90;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_180:
+      return kDrmRotate180;
+    case gfx::OVERLAY_TRANSFORM_ROTATE_270:
+      return kDrmRotate270;
+    default:
+      NOTREACHED();
+  }
+  return kDrmRotate0;
+}
 
 }  // namespace
 
 HardwareDisplayPlaneAtomic::Property::Property() {
 }
 
 bool HardwareDisplayPlaneAtomic::Property::Initialize(
     DrmDevice* drm,
     const char* name,
     const ScopedDrmObjectPropertyPtr& plane_props) {
@@ skipping 12 matching lines @@
   return true;
 }
 
 HardwareDisplayPlaneAtomic::HardwareDisplayPlaneAtomic(uint32_t plane_id,
                                                        uint32_t possible_crtcs)
     : HardwareDisplayPlane(plane_id, possible_crtcs) {
 }
 HardwareDisplayPlaneAtomic::~HardwareDisplayPlaneAtomic() {
 }
 
-bool HardwareDisplayPlaneAtomic::SetPlaneData(drmModeAtomicReq* property_set,
-                                              uint32_t crtc_id,
-                                              uint32_t framebuffer,
-                                              const gfx::Rect& crtc_rect,
-                                              const gfx::Rect& src_rect) {
+bool HardwareDisplayPlaneAtomic::SetPlaneData(
+    drmModeAtomicReq* property_set,
+    uint32_t crtc_id,
+    uint32_t framebuffer,
+    const gfx::Rect& crtc_rect,
+    const gfx::Rect& src_rect,
+    const gfx::OverlayTransform transform) {
   int plane_set_succeeded =
       drmModeAtomicAddProperty(property_set, plane_id_, crtc_prop_.id,
                                crtc_id) &&
       drmModeAtomicAddProperty(property_set, plane_id_, fb_prop_.id,
                                framebuffer) &&
       drmModeAtomicAddProperty(property_set, plane_id_, crtc_x_prop_.id,
                                crtc_rect.x()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, crtc_y_prop_.id,
                                crtc_rect.y()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, crtc_w_prop_.id,
                                crtc_rect.width()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, crtc_h_prop_.id,
                                crtc_rect.height()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, src_x_prop_.id,
                                src_rect.x()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, src_y_prop_.id,
                                src_rect.x()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, src_w_prop_.id,
                                src_rect.width()) &&
       drmModeAtomicAddProperty(property_set, plane_id_, src_h_prop_.id,
-                               src_rect.height());
+                               src_rect.height()) &&
+      drmModeAtomicAddProperty(
+          property_set, plane_id_, rotation_prop_.id,
+          OverlayTransformToDrmRotationPropertyValue(transform));
   if (!plane_set_succeeded) {
     PLOG(ERROR) << "Failed to set plane data";
     return false;
   }
   return true;
 }
 
 bool HardwareDisplayPlaneAtomic::InitializeProperties(
     DrmDevice* drm,
     const ScopedDrmObjectPropertyPtr& plane_props) {
-  bool props_init = crtc_prop_.Initialize(drm, kCrtcPropName, plane_props) &&
-                    fb_prop_.Initialize(drm, kFbPropName, plane_props) &&
-                    crtc_x_prop_.Initialize(drm, kCrtcXPropName, plane_props) &&
-                    crtc_y_prop_.Initialize(drm, kCrtcYPropName, plane_props) &&
-                    crtc_w_prop_.Initialize(drm, kCrtcWPropName, plane_props) &&
-                    crtc_h_prop_.Initialize(drm, kCrtcHPropName, plane_props) &&
-                    src_x_prop_.Initialize(drm, kSrcXPropName, plane_props) &&
-                    src_y_prop_.Initialize(drm, kSrcYPropName, plane_props) &&
-                    src_w_prop_.Initialize(drm, kSrcWPropName, plane_props) &&
-                    src_h_prop_.Initialize(drm, kSrcHPropName, plane_props);
+  bool props_init =
+      crtc_prop_.Initialize(drm, kCrtcPropName, plane_props) &&
+      fb_prop_.Initialize(drm, kFbPropName, plane_props) &&
+      crtc_x_prop_.Initialize(drm, kCrtcXPropName, plane_props) &&
+      crtc_y_prop_.Initialize(drm, kCrtcYPropName, plane_props) &&
+      crtc_w_prop_.Initialize(drm, kCrtcWPropName, plane_props) &&
+      crtc_h_prop_.Initialize(drm, kCrtcHPropName, plane_props) &&
+      src_x_prop_.Initialize(drm, kSrcXPropName, plane_props) &&
+      src_y_prop_.Initialize(drm, kSrcYPropName, plane_props) &&
+      src_w_prop_.Initialize(drm, kSrcWPropName, plane_props) &&
+      src_h_prop_.Initialize(drm, kSrcHPropName, plane_props) &&
+      rotation_prop_.Initialize(drm, kRotationPropName, plane_props);
 
   if (!props_init) {
     LOG(ERROR) << "Unable to get plane properties.";
     return false;
   }
 
   return true;
 }
 
 }  // namespace ui