drm_hwcomposer: Reorganize struct DrmHwcLayer
1. Move BlendMode, ColorSpace, SampleRange fields to the struct BufferInfo,
allowing extraction of the data from native_handle using Metadata@4 API.
Use it when data from HWC2 API can't be used (Currently it's a BlendMode
case for CLIENT layer)
2. Rename DrmHwcLayer to LayerData and move it to compositor/ directory.
(I was confused in the past because of similarity of names DrmHwcLayer
vs HwcLayer, so this step should meke it easier for newcomers to
understand the code)
3. Allow clonning of the LayerData to propagate it through the composition
pipeline. Thus LayerData can be used by both HwcLayer to track state
and by the compositor.
Signed-off-by: Roman Stratiienko <roman.o.stratiienko@globallogic.com>
diff --git a/drm/DrmAtomicStateManager.cpp b/drm/DrmAtomicStateManager.cpp
index bca446c..5d2eebd 100644
--- a/drm/DrmAtomicStateManager.cpp
+++ b/drm/DrmAtomicStateManager.cpp
@@ -109,9 +109,9 @@
for (auto &joining : args.composition->plan) {
DrmPlane *plane = joining.plane->Get();
- DrmHwcLayer &layer = joining.layer;
+ LayerData &layer = joining.layer;
- new_frame_state.used_framebuffers.emplace_back(layer.fb_id_handle);
+ new_frame_state.used_framebuffers.emplace_back(layer.fb);
new_frame_state.used_planes.emplace_back(joining.plane);
/* Remove from 'unused' list, since plane is re-used */
diff --git a/drm/DrmAtomicStateManager.h b/drm/DrmAtomicStateManager.h
index a50a214..b0b85ac 100644
--- a/drm/DrmAtomicStateManager.h
+++ b/drm/DrmAtomicStateManager.h
@@ -26,10 +26,10 @@
#include <tuple>
#include "compositor/DrmKmsPlan.h"
+#include "compositor/LayerData.h"
#include "drm/DrmPlane.h"
#include "drm/ResourceManager.h"
#include "drm/VSyncWorker.h"
-#include "drmhwcomposer.h"
namespace android {
diff --git a/drm/DrmPlane.cpp b/drm/DrmPlane.cpp
index 12ac44f..329ef1c 100644
--- a/drm/DrmPlane.cpp
+++ b/drm/DrmPlane.cpp
@@ -91,17 +91,17 @@
GetPlaneProperty("zpos", zpos_property_, Presence::kOptional);
if (GetPlaneProperty("rotation", rotation_property_, Presence::kOptional)) {
- rotation_property_.AddEnumToMap("rotate-0", DrmHwcTransform::kIdentity,
+ rotation_property_.AddEnumToMap("rotate-0", LayerTransform::kIdentity,
transform_enum_map_);
- rotation_property_.AddEnumToMap("rotate-90", DrmHwcTransform::kRotate90,
+ rotation_property_.AddEnumToMap("rotate-90", LayerTransform::kRotate90,
transform_enum_map_);
- rotation_property_.AddEnumToMap("rotate-180", DrmHwcTransform::kRotate180,
+ rotation_property_.AddEnumToMap("rotate-180", LayerTransform::kRotate180,
transform_enum_map_);
- rotation_property_.AddEnumToMap("rotate-270", DrmHwcTransform::kRotate270,
+ rotation_property_.AddEnumToMap("rotate-270", LayerTransform::kRotate270,
transform_enum_map_);
- rotation_property_.AddEnumToMap("reflect-x", DrmHwcTransform::kFlipH,
+ rotation_property_.AddEnumToMap("reflect-x", LayerTransform::kFlipH,
transform_enum_map_);
- rotation_property_.AddEnumToMap("reflect-y", DrmHwcTransform::kFlipV,
+ rotation_property_.AddEnumToMap("reflect-y", LayerTransform::kFlipV,
transform_enum_map_);
}
@@ -109,11 +109,11 @@
if (GetPlaneProperty("pixel blend mode", blend_property_,
Presence::kOptional)) {
- blend_property_.AddEnumToMap("Pre-multiplied", DrmHwcBlending::kPreMult,
+ blend_property_.AddEnumToMap("Pre-multiplied", BufferBlendMode::kPreMult,
blending_enum_map_);
- blend_property_.AddEnumToMap("Coverage", DrmHwcBlending::kCoverage,
+ blend_property_.AddEnumToMap("Coverage", BufferBlendMode::kCoverage,
blending_enum_map_);
- blend_property_.AddEnumToMap("None", DrmHwcBlending::kNone,
+ blend_property_.AddEnumToMap("None", BufferBlendMode::kNone,
blending_enum_map_);
}
@@ -123,23 +123,23 @@
if (GetPlaneProperty("COLOR_ENCODING", color_encoding_propery_,
Presence::kOptional)) {
color_encoding_propery_.AddEnumToMap("ITU-R BT.709 YCbCr",
- DrmHwcColorSpace::kItuRec709,
+ BufferColorSpace::kItuRec709,
color_encoding_enum_map_);
color_encoding_propery_.AddEnumToMap("ITU-R BT.601 YCbCr",
- DrmHwcColorSpace::kItuRec601,
+ BufferColorSpace::kItuRec601,
color_encoding_enum_map_);
color_encoding_propery_.AddEnumToMap("ITU-R BT.2020 YCbCr",
- DrmHwcColorSpace::kItuRec2020,
+ BufferColorSpace::kItuRec2020,
color_encoding_enum_map_);
}
if (GetPlaneProperty("COLOR_RANGE", color_range_property_,
Presence::kOptional)) {
color_range_property_.AddEnumToMap("YCbCr full range",
- DrmHwcSampleRange::kFullRange,
+ BufferSampleRange::kFullRange,
color_range_enum_map_);
color_range_property_.AddEnumToMap("YCbCr limited range",
- DrmHwcSampleRange::kLimitedRange,
+ BufferSampleRange::kLimitedRange,
color_range_enum_map_);
}
}
@@ -151,32 +151,32 @@
return ((1 << crtc.GetIndexInResArray()) & plane_->possible_crtcs) != 0;
}
-bool DrmPlane::IsValidForLayer(DrmHwcLayer *layer) {
+bool DrmPlane::IsValidForLayer(LayerData *layer) {
if (!rotation_property_) {
- if (layer->transform != DrmHwcTransform::kIdentity) {
+ if (layer->pi.transform != LayerTransform::kIdentity) {
ALOGV("No rotation property on plane %d", GetId());
return false;
}
} else {
- if (transform_enum_map_.count(layer->transform) == 0) {
+ if (transform_enum_map_.count(layer->pi.transform) == 0) {
ALOGV("Transform is not supported on plane %d", GetId());
return false;
}
}
- if (alpha_property_.id() == 0 && layer->alpha != UINT16_MAX) {
+ if (alpha_property_.id() == 0 && layer->pi.alpha != UINT16_MAX) {
ALOGV("Alpha is not supported on plane %d", GetId());
return false;
}
- if (blending_enum_map_.count(layer->blending) == 0 &&
- layer->blending != DrmHwcBlending::kNone &&
- layer->blending != DrmHwcBlending::kPreMult) {
+ if (blending_enum_map_.count(layer->bi->blend_mode) == 0 &&
+ layer->bi->blend_mode != BufferBlendMode::kNone &&
+ layer->bi->blend_mode != BufferBlendMode::kPreMult) {
ALOGV("Blending is not supported on plane %d", GetId());
return false;
}
- uint32_t format = layer->buffer_info->format;
+ uint32_t format = layer->bi->format;
if (!IsFormatSupported(format)) {
ALOGV("Plane %d does not supports %c%c%c%c format", GetId(), format,
format >> 8, format >> 16, format >> 24);
@@ -198,17 +198,17 @@
}) != std::end(formats_);
}
-static uint64_t ToDrmRotation(DrmHwcTransform transform) {
+static uint64_t ToDrmRotation(LayerTransform transform) {
uint64_t rotation = 0;
- if ((transform & DrmHwcTransform::kFlipH) != 0)
+ if ((transform & LayerTransform::kFlipH) != 0)
rotation |= DRM_MODE_REFLECT_X;
- if ((transform & DrmHwcTransform::kFlipV) != 0)
+ if ((transform & LayerTransform::kFlipV) != 0)
rotation |= DRM_MODE_REFLECT_Y;
- if ((transform & DrmHwcTransform::kRotate90) != 0)
+ if ((transform & LayerTransform::kRotate90) != 0)
rotation |= DRM_MODE_ROTATE_90;
- else if ((transform & DrmHwcTransform::kRotate180) != 0)
+ else if ((transform & LayerTransform::kRotate180) != 0)
rotation |= DRM_MODE_ROTATE_180;
- else if ((transform & DrmHwcTransform::kRotate270) != 0)
+ else if ((transform & LayerTransform::kRotate270) != 0)
rotation |= DRM_MODE_ROTATE_270;
else
rotation |= DRM_MODE_ROTATE_0;
@@ -222,9 +222,9 @@
return int(in * (1 << kBitShift));
}
-auto DrmPlane::AtomicSetState(drmModeAtomicReq &pset, DrmHwcLayer &layer,
+auto DrmPlane::AtomicSetState(drmModeAtomicReq &pset, LayerData &layer,
uint32_t zpos, uint32_t crtc_id) -> int {
- if (!layer.fb_id_handle) {
+ if (!layer.fb) {
ALOGE("Expected a valid framebuffer for pset");
return -EINVAL;
}
@@ -245,46 +245,45 @@
return -EINVAL;
}
+ auto &disp = layer.pi.display_frame;
+ auto &src = layer.pi.source_crop;
if (!crtc_property_.AtomicSet(pset, crtc_id) ||
- !fb_property_.AtomicSet(pset, layer.fb_id_handle->GetFbId()) ||
- !crtc_x_property_.AtomicSet(pset, layer.display_frame.left) ||
- !crtc_y_property_.AtomicSet(pset, layer.display_frame.top) ||
- !crtc_w_property_.AtomicSet(pset, layer.display_frame.right -
- layer.display_frame.left) ||
- !crtc_h_property_.AtomicSet(pset, layer.display_frame.bottom -
- layer.display_frame.top) ||
- !src_x_property_.AtomicSet(pset, To1616FixPt(layer.source_crop.left)) ||
- !src_y_property_.AtomicSet(pset, To1616FixPt(layer.source_crop.top)) ||
- !src_w_property_.AtomicSet(pset, To1616FixPt(layer.source_crop.right -
- layer.source_crop.left)) ||
- !src_h_property_.AtomicSet(pset, To1616FixPt(layer.source_crop.bottom -
- layer.source_crop.top))) {
+ !fb_property_.AtomicSet(pset, layer.fb->GetFbId()) ||
+ !crtc_x_property_.AtomicSet(pset, disp.left) ||
+ !crtc_y_property_.AtomicSet(pset, disp.top) ||
+ !crtc_w_property_.AtomicSet(pset, disp.right - disp.left) ||
+ !crtc_h_property_.AtomicSet(pset, disp.bottom - disp.top) ||
+ !src_x_property_.AtomicSet(pset, To1616FixPt(src.left)) ||
+ !src_y_property_.AtomicSet(pset, To1616FixPt(src.top)) ||
+ !src_w_property_.AtomicSet(pset, To1616FixPt(src.right - src.left)) ||
+ !src_h_property_.AtomicSet(pset, To1616FixPt(src.bottom - src.top))) {
return -EINVAL;
}
if (rotation_property_ &&
- !rotation_property_.AtomicSet(pset, ToDrmRotation(layer.transform))) {
+ !rotation_property_.AtomicSet(pset, ToDrmRotation(layer.pi.transform))) {
return -EINVAL;
}
- if (alpha_property_ && !alpha_property_.AtomicSet(pset, layer.alpha)) {
+ if (alpha_property_ && !alpha_property_.AtomicSet(pset, layer.pi.alpha)) {
return -EINVAL;
}
- if (blending_enum_map_.count(layer.blending) != 0 &&
- !blend_property_.AtomicSet(pset, blending_enum_map_[layer.blending])) {
+ if (blending_enum_map_.count(layer.bi->blend_mode) != 0 &&
+ !blend_property_.AtomicSet(pset,
+ blending_enum_map_[layer.bi->blend_mode])) {
return -EINVAL;
}
- if (color_encoding_enum_map_.count(layer.color_space) != 0 &&
+ if (color_encoding_enum_map_.count(layer.bi->color_space) != 0 &&
!color_encoding_propery_
- .AtomicSet(pset, color_encoding_enum_map_[layer.color_space])) {
+ .AtomicSet(pset, color_encoding_enum_map_[layer.bi->color_space])) {
return -EINVAL;
}
- if (color_range_enum_map_.count(layer.sample_range) != 0 &&
+ if (color_range_enum_map_.count(layer.bi->sample_range) != 0 &&
!color_range_property_
- .AtomicSet(pset, color_range_enum_map_[layer.sample_range])) {
+ .AtomicSet(pset, color_range_enum_map_[layer.bi->sample_range])) {
return -EINVAL;
}
diff --git a/drm/DrmPlane.h b/drm/DrmPlane.h
index 65f458f..31f0a33 100644
--- a/drm/DrmPlane.h
+++ b/drm/DrmPlane.h
@@ -24,12 +24,12 @@
#include "DrmCrtc.h"
#include "DrmProperty.h"
-#include "drmhwcomposer.h"
+#include "compositor/LayerData.h"
namespace android {
class DrmDevice;
-struct DrmHwcLayer;
+struct LayerData;
class DrmPlane : public PipelineBindable<DrmPlane> {
public:
@@ -40,7 +40,7 @@
-> std::unique_ptr<DrmPlane>;
bool IsCrtcSupported(const DrmCrtc &crtc) const;
- bool IsValidForLayer(DrmHwcLayer *layer);
+ bool IsValidForLayer(LayerData *layer);
auto GetType() const {
return type_;
@@ -49,7 +49,7 @@
bool IsFormatSupported(uint32_t format) const;
bool HasNonRgbFormat() const;
- auto AtomicSetState(drmModeAtomicReq &pset, DrmHwcLayer &layer, uint32_t zpos,
+ auto AtomicSetState(drmModeAtomicReq &pset, LayerData &layer, uint32_t zpos,
uint32_t crtc_id) -> int;
auto AtomicDisablePlane(drmModeAtomicReq &pset) -> int;
auto &GetZPosProperty() const {
@@ -94,10 +94,10 @@
DrmProperty color_encoding_propery_;
DrmProperty color_range_property_;
- std::map<DrmHwcBlending, uint64_t> blending_enum_map_;
- std::map<DrmHwcColorSpace, uint64_t> color_encoding_enum_map_;
- std::map<DrmHwcSampleRange, uint64_t> color_range_enum_map_;
- std::map<DrmHwcTransform, uint64_t> transform_enum_map_;
+ std::map<BufferBlendMode, uint64_t> blending_enum_map_;
+ std::map<BufferColorSpace, uint64_t> color_encoding_enum_map_;
+ std::map<BufferSampleRange, uint64_t> color_range_enum_map_;
+ std::map<LayerTransform, uint64_t> transform_enum_map_;
};
} // namespace android