drm/DrmPlane.cpp

   1 /*
   2  * Copyright (C) 2015 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "hwc-drm-plane"
  18
  19 #include "DrmPlane.h"
  20
  21 #include <algorithm>
  22 #include <cerrno>
  23 #include <cinttypes>
  24 #include <cstdint>
  25
  26 #include "DrmDevice.h"
  27 #include "bufferinfo/BufferInfoGetter.h"
  28 #include "utils/log.h"
  29
  30 namespace android {
  31
  32 DrmPlane::DrmPlane(DrmDevice *drm, drmModePlanePtr p)
  33     : drm_(drm),
  34       id_(p->plane_id),
  35       possible_crtc_mask_(p->possible_crtcs),
  36       formats_(p->formats, p->formats + p->count_formats) {
  37 }
  38
  39 int DrmPlane::Init() {
  40   uint64_t enum_value = UINT64_MAX;
  41   DrmProperty p;
  42
  43   int ret = drm_->GetPlaneProperty(*this, "type", &p);
  44   if (ret) {
  45     ALOGE("Could not get plane type property");
  46     return ret;
  47   }
  48
  49   uint64_t type = 0;
  50   std::tie(ret, type) = p.value();
  51   if (ret) {
  52     ALOGE("Failed to get plane type property value");
  53     return ret;
  54   }
  55   switch (type) {
  56     case DRM_PLANE_TYPE_OVERLAY:
  57     case DRM_PLANE_TYPE_PRIMARY:
  58     case DRM_PLANE_TYPE_CURSOR:
  59       type_ = (uint32_t)type;
  60       break;
  61     default:
  62       ALOGE("Invalid plane type %" PRIu64, type);
  63       return -EINVAL;
  64   }
  65
  66   ret = drm_->GetPlaneProperty(*this, "CRTC_ID", &crtc_property_);
  67   if (ret) {
  68     ALOGE("Could not get CRTC_ID property");
  69     return ret;
  70   }
  71
  72   ret = drm_->GetPlaneProperty(*this, "FB_ID", &fb_property_);
  73   if (ret) {
  74     ALOGE("Could not get FB_ID property");
  75     return ret;
  76   }
  77
  78   ret = drm_->GetPlaneProperty(*this, "CRTC_X", &crtc_x_property_);
  79   if (ret) {
  80     ALOGE("Could not get CRTC_X property");
  81     return ret;
  82   }
  83
  84   ret = drm_->GetPlaneProperty(*this, "CRTC_Y", &crtc_y_property_);
  85   if (ret) {
  86     ALOGE("Could not get CRTC_Y property");
  87     return ret;
  88   }
  89
  90   ret = drm_->GetPlaneProperty(*this, "CRTC_W", &crtc_w_property_);
  91   if (ret) {
  92     ALOGE("Could not get CRTC_W property");
  93     return ret;
  94   }
  95
  96   ret = drm_->GetPlaneProperty(*this, "CRTC_H", &crtc_h_property_);
  97   if (ret) {
  98     ALOGE("Could not get CRTC_H property");
  99     return ret;
 100   }
 101
 102   ret = drm_->GetPlaneProperty(*this, "SRC_X", &src_x_property_);
 103   if (ret) {
 104     ALOGE("Could not get SRC_X property");
 105     return ret;
 106   }
 107
 108   ret = drm_->GetPlaneProperty(*this, "SRC_Y", &src_y_property_);
 109   if (ret) {
 110     ALOGE("Could not get SRC_Y property");
 111     return ret;
 112   }
 113
 114   ret = drm_->GetPlaneProperty(*this, "SRC_W", &src_w_property_);
 115   if (ret) {
 116     ALOGE("Could not get SRC_W property");
 117     return ret;
 118   }
 119
 120   ret = drm_->GetPlaneProperty(*this, "SRC_H", &src_h_property_);
 121   if (ret) {
 122     ALOGE("Could not get SRC_H property");
 123     return ret;
 124   }
 125
 126   ret = drm_->GetPlaneProperty(*this, "zpos", &zpos_property_);
 127   if (ret)
 128     ALOGE("Could not get zpos property for plane %u", id());
 129
 130   ret = drm_->GetPlaneProperty(*this, "rotation", &rotation_property_);
 131   if (ret)
 132     ALOGE("Could not get rotation property");
 133
 134   ret = drm_->GetPlaneProperty(*this, "alpha", &alpha_property_);
 135   if (ret)
 136     ALOGI("Could not get alpha property");
 137
 138   ret = drm_->GetPlaneProperty(*this, "pixel blend mode", &blend_property_);
 139   if (ret == 0) {
 140     std::tie(enum_value,
 141              ret) = blend_property_.GetEnumValueWithName("Pre-multiplied");
 142     if (ret == 0) {
 143       blending_enum_map_[DrmHwcBlending::kPreMult] = enum_value;
 144     }
 145     std::tie(enum_value,
 146              ret) = blend_property_.GetEnumValueWithName("Coverage");
 147     if (ret == 0) {
 148       blending_enum_map_[DrmHwcBlending::kCoverage] = enum_value;
 149     }
 150     std::tie(enum_value, ret) = blend_property_.GetEnumValueWithName("None");
 151     if (ret == 0) {
 152       blending_enum_map_[DrmHwcBlending::kNone] = enum_value;
 153     }
 154   } else {
 155     ALOGI("Could not get pixel blend mode property");
 156   }
 157
 158   ret = drm_->GetPlaneProperty(*this, "IN_FENCE_FD", &in_fence_fd_property_);
 159   if (ret)
 160     ALOGI("Could not get IN_FENCE_FD property");
 161
 162   if (HasNonRgbFormat()) {
 163     ret = drm_->GetPlaneProperty(*this, "COLOR_ENCODING",
 164                                  &color_encoding_propery_);
 165     if (ret == 0) {
 166       std::tie(enum_value, ret) = color_encoding_propery_.GetEnumValueWithName(
 167           "ITU-R BT.709 YCbCr");
 168       if (ret == 0) {
 169         color_encoding_enum_map_[DrmHwcColorSpace::kItuRec709] = enum_value;
 170       }
 171       std::tie(enum_value, ret) = color_encoding_propery_.GetEnumValueWithName(
 172           "ITU-R BT.601 YCbCr");
 173       if (ret == 0) {
 174         color_encoding_enum_map_[DrmHwcColorSpace::kItuRec601] = enum_value;
 175       }
 176       std::tie(enum_value, ret) = color_encoding_propery_.GetEnumValueWithName(
 177           "ITU-R BT.2020 YCbCr");
 178       if (ret == 0) {
 179         color_encoding_enum_map_[DrmHwcColorSpace::kItuRec2020] = enum_value;
 180       }
 181     } else {
 182       ALOGI("Could not get COLOR_ENCODING property");
 183     }
 184
 185     ret = drm_->GetPlaneProperty(*this, "COLOR_RANGE", &color_range_property_);
 186     if (ret == 0) {
 187       std::tie(enum_value, ret) = color_range_property_.GetEnumValueWithName(
 188           "YCbCr full range");
 189       if (ret == 0) {
 190         color_range_enum_map_[DrmHwcSampleRange::kFullRange] = enum_value;
 191       }
 192       std::tie(enum_value, ret) = color_range_property_.GetEnumValueWithName(
 193           "YCbCr limited range");
 194       if (ret == 0) {
 195         color_range_enum_map_[DrmHwcSampleRange::kLimitedRange] = enum_value;
 196       }
 197     } else {
 198       ALOGI("Could not get COLOR_RANGE property");
 199     }
 200   }
 201
 202   return 0;
 203 }
 204
 205 uint32_t DrmPlane::id() const {
 206   return id_;
 207 }
 208
 209 bool DrmPlane::GetCrtcSupported(const DrmCrtc &crtc) const {
 210   return ((1 << crtc.pipe()) & possible_crtc_mask_) != 0;
 211 }
 212
 213 bool DrmPlane::IsValidForLayer(DrmHwcLayer *layer) {
 214   if (rotation_property_.id() == 0) {
 215     if (layer->transform != DrmHwcTransform::kIdentity) {
 216       ALOGV("Rotation is not supported on plane %d", id_);
 217       return false;
 218     }
 219   } else {
 220     // For rotation checks, we assume the hardware reports its capabilities
 221     // consistently (e.g. a 270 degree rotation is a 90 degree rotation + H
 222     // flip + V flip; it wouldn't make sense to support all of the latter but
 223     // not the former).
 224     int ret = 0;
 225     const std::pair<enum DrmHwcTransform, std::string> transforms[] =
 226         {{kFlipH, "reflect-x"},
 227          {kFlipV, "reflect-y"},
 228          {kRotate90, "rotate-90"},
 229          {kRotate180, "rotate-180"},
 230          {kRotate270, "rotate-270"}};
 231
 232     for (const auto &[transform, name] : transforms) {
 233       if (layer->transform & transform) {
 234         std::tie(std::ignore,
 235                  ret) = rotation_property_.GetEnumValueWithName(name);
 236         if (ret) {
 237           ALOGV("Rotation '%s' is not supported on plane %d", name.c_str(),
 238                 id_);
 239           return false;
 240         }
 241       }
 242     }
 243   }
 244
 245   if (alpha_property_.id() == 0 && layer->alpha != 0xffff) {
 246     ALOGV("Alpha is not supported on plane %d", id_);
 247     return false;
 248   }
 249
 250   if (blending_enum_map_.count(layer->blending) == 0 &&
 251       layer->blending != DrmHwcBlending::kNone) {
 252     ALOGV("Blending is not supported on plane %d", id_);
 253     return false;
 254   }
 255
 256   uint32_t format = layer->buffer_info.format;
 257   if (!IsFormatSupported(format)) {
 258     ALOGV("Plane %d does not supports %c%c%c%c format", id_, format,
 259           format >> 8, format >> 16, format >> 24);
 260     return false;
 261   }
 262
 263   return true;
 264 }
 265
 266 uint32_t DrmPlane::type() const {
 267   return type_;
 268 }
 269
 270 bool DrmPlane::IsFormatSupported(uint32_t format) const {
 271   return std::find(std::begin(formats_), std::end(formats_), format) !=
 272          std::end(formats_);
 273 }
 274
 275 bool DrmPlane::HasNonRgbFormat() const {
 276   return std::find_if_not(std::begin(formats_), std::end(formats_),
 277                           [](uint32_t format) {
 278                             return BufferInfoGetter::IsDrmFormatRgb(format);
 279                           }) != std::end(formats_);
 280 }
 281
 282 auto DrmPlane::AtomicSetState(drmModeAtomicReq &pset, DrmHwcLayer &layer,
 283                               uint32_t zpos, uint32_t crtc_id) -> int {
 284   uint32_t fb_id = UINT32_MAX;
 285   int fence_fd = -1;
 286   hwc_rect_t display_frame;
 287   hwc_frect_t source_crop;
 288   uint64_t rotation = 0;
 289   uint64_t alpha = 0xFFFF;
 290
 291   if (!layer.FbIdHandle) {
 292     ALOGE("Expected a valid framebuffer for pset");
 293     return -EINVAL;
 294   }
 295
 296   fb_id = layer.FbIdHandle->GetFbId();
 297   fence_fd = layer.acquire_fence.Get();
 298   display_frame = layer.display_frame;
 299   source_crop = layer.source_crop;
 300   alpha = layer.alpha;
 301
 302   // Disable the plane if there's no framebuffer
 303   if (fb_id == UINT32_MAX) {
 304     if (!AtomicDisablePlane(pset)) {
 305       return -EINVAL;
 306     }
 307     return 0;
 308   }
 309
 310   if (zpos_property_ && !zpos_property_.is_immutable()) {
 311     uint64_t min_zpos = 0;
 312
 313     // Ignore ret and use min_zpos as 0 by default
 314     std::tie(std::ignore, min_zpos) = zpos_property_.range_min();
 315
 316     if (!zpos_property_.AtomicSet(pset, zpos + min_zpos)) {
 317       return -EINVAL;
 318     }
 319   }
 320
 321   rotation = 0;
 322   if (layer.transform & DrmHwcTransform::kFlipH)
 323     rotation |= DRM_MODE_REFLECT_X;
 324   if (layer.transform & DrmHwcTransform::kFlipV)
 325     rotation |= DRM_MODE_REFLECT_Y;
 326   if (layer.transform & DrmHwcTransform::kRotate90)
 327     rotation |= DRM_MODE_ROTATE_90;
 328   else if (layer.transform & DrmHwcTransform::kRotate180)
 329     rotation |= DRM_MODE_ROTATE_180;
 330   else if (layer.transform & DrmHwcTransform::kRotate270)
 331     rotation |= DRM_MODE_ROTATE_270;
 332   else
 333     rotation |= DRM_MODE_ROTATE_0;
 334
 335   if (fence_fd >= 0) {
 336     if (!in_fence_fd_property_.AtomicSet(pset, fence_fd)) {
 337       return -EINVAL;
 338     }
 339   }
 340
 341   if (!crtc_property_.AtomicSet(pset, crtc_id) ||
 342       !fb_property_.AtomicSet(pset, fb_id) ||
 343       !crtc_x_property_.AtomicSet(pset, display_frame.left) ||
 344       !crtc_y_property_.AtomicSet(pset, display_frame.top) ||
 345       !crtc_w_property_.AtomicSet(pset,
 346                                   display_frame.right - display_frame.left) ||
 347       !crtc_h_property_.AtomicSet(pset,
 348                                   display_frame.bottom - display_frame.top) ||
 349       !src_x_property_.AtomicSet(pset, (int)(source_crop.left) << 16) ||
 350       !src_y_property_.AtomicSet(pset, (int)(source_crop.top) << 16) ||
 351       !src_w_property_.AtomicSet(pset,
 352                                  (int)(source_crop.right - source_crop.left)
 353                                      << 16) ||
 354       !src_h_property_.AtomicSet(pset,
 355                                  (int)(source_crop.bottom - source_crop.top)
 356                                      << 16)) {
 357     return -EINVAL;
 358   }
 359
 360   if (rotation_property_) {
 361     if (!rotation_property_.AtomicSet(pset, rotation)) {
 362       return -EINVAL;
 363     }
 364   }
 365
 366   if (alpha_property_) {
 367     if (!alpha_property_.AtomicSet(pset, alpha)) {
 368       return -EINVAL;
 369     }
 370   }
 371
 372   if (blending_enum_map_.count(layer.blending) != 0 &&
 373       !blend_property_.AtomicSet(pset, blending_enum_map_[layer.blending])) {
 374     return -EINVAL;
 375   }
 376
 377   if (color_encoding_enum_map_.count(layer.color_space) != 0 &&
 378       !color_encoding_propery_
 379            .AtomicSet(pset, color_encoding_enum_map_[layer.color_space])) {
 380     return -EINVAL;
 381   }
 382
 383   if (color_range_enum_map_.count(layer.sample_range) != 0 &&
 384       !color_range_property_
 385            .AtomicSet(pset, color_range_enum_map_[layer.sample_range])) {
 386     return -EINVAL;
 387   }
 388
 389   return 0;
 390 }
 391
 392 auto DrmPlane::AtomicDisablePlane(drmModeAtomicReq &pset) -> int {
 393   if (!crtc_property_.AtomicSet(pset, 0) || !fb_property_.AtomicSet(pset, 0)) {
 394     return -EINVAL;
 395   }
 396
 397   return 0;
 398 }
 399
 400 const DrmProperty &DrmPlane::zpos_property() const {
 401   return zpos_property_;
 402 }
 403
 404 }  // namespace android