2 * Copyright (C) 2016 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #ifndef ANDROID_DRM_HWC_TWO_H_
18 #define ANDROID_DRM_HWC_TWO_H_
20 #include <hardware/hwcomposer2.h>
26 #include "compositor/DrmDisplayCompositor.h"
27 #include "compositor/Planner.h"
28 #include "drm/DrmGenericImporter.h"
29 #include "drm/ResourceManager.h"
30 #include "drm/VSyncWorker.h"
31 #include "drmhwcomposer.h"
37 class DrmHwcTwo : public hwc2_device_t {
39 static int HookDevOpen(const struct hw_module_t *module, const char *name,
40 struct hw_device_t **dev);
46 hwc2_callback_data_t hotplug_callback_data_ = NULL;
47 HWC2_PFN_HOTPLUG hotplug_callback_hook_ = NULL;
48 std::mutex hotplug_callback_lock;
50 void SetHotplugCallback(hwc2_callback_data_t data,
51 hwc2_function_pointer_t hook) {
52 const std::lock_guard<std::mutex> lock(hotplug_callback_lock);
53 hotplug_callback_data_ = data;
54 hotplug_callback_hook_ = reinterpret_cast<HWC2_PFN_HOTPLUG>(hook);
59 HWC2::Composition sf_type() const {
62 HWC2::Composition validated_type() const {
63 return validated_type_;
65 void accept_type_change() {
66 sf_type_ = validated_type_;
68 void set_validated_type(HWC2::Composition type) {
69 validated_type_ = type;
71 bool type_changed() const {
72 return sf_type_ != validated_type_;
75 uint32_t z_order() const {
79 buffer_handle_t buffer() {
82 void set_buffer(buffer_handle_t buffer) {
86 int take_acquire_fence() {
87 return acquire_fence_.Release();
89 void set_acquire_fence(int acquire_fence) {
90 acquire_fence_.Set(dup(acquire_fence));
94 return release_fence_.get();
96 int take_release_fence() {
97 return release_fence_.Release();
99 void manage_release_fence() {
100 release_fence_.Set(release_fence_raw_);
101 release_fence_raw_ = -1;
103 OutputFd release_fence_output() {
104 return OutputFd(&release_fence_raw_);
107 hwc_rect_t display_frame() {
108 return display_frame_;
111 void PopulateDrmLayer(DrmHwcLayer *layer);
113 bool RequireScalingOrPhasing() {
114 float src_width = source_crop_.right - source_crop_.left;
115 float src_height = source_crop_.bottom - source_crop_.top;
117 float dest_width = display_frame_.right - display_frame_.left;
118 float dest_height = display_frame_.bottom - display_frame_.top;
120 bool scaling = src_width != dest_width || src_height != dest_height;
121 bool phasing = (source_crop_.left - floor(source_crop_.left) != 0) ||
122 (source_crop_.top - floor(source_crop_.top) != 0);
123 return scaling || phasing;
127 HWC2::Error SetCursorPosition(int32_t x, int32_t y);
128 HWC2::Error SetLayerBlendMode(int32_t mode);
129 HWC2::Error SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence);
130 HWC2::Error SetLayerColor(hwc_color_t color);
131 HWC2::Error SetLayerCompositionType(int32_t type);
132 HWC2::Error SetLayerDataspace(int32_t dataspace);
133 HWC2::Error SetLayerDisplayFrame(hwc_rect_t frame);
134 HWC2::Error SetLayerPlaneAlpha(float alpha);
135 HWC2::Error SetLayerSidebandStream(const native_handle_t *stream);
136 HWC2::Error SetLayerSourceCrop(hwc_frect_t crop);
137 HWC2::Error SetLayerSurfaceDamage(hwc_region_t damage);
138 HWC2::Error SetLayerTransform(int32_t transform);
139 HWC2::Error SetLayerVisibleRegion(hwc_region_t visible);
140 HWC2::Error SetLayerZOrder(uint32_t order);
143 // sf_type_ stores the initial type given to us by surfaceflinger,
144 // validated_type_ stores the type after running ValidateDisplay
145 HWC2::Composition sf_type_ = HWC2::Composition::Invalid;
146 HWC2::Composition validated_type_ = HWC2::Composition::Invalid;
148 HWC2::BlendMode blending_ = HWC2::BlendMode::None;
149 buffer_handle_t buffer_ = NULL;
150 UniqueFd acquire_fence_;
151 int release_fence_raw_ = -1;
152 UniqueFd release_fence_;
153 hwc_rect_t display_frame_;
155 hwc_frect_t source_crop_;
158 hwc_color_t layer_color_;
159 HWC2::Transform transform_ = HWC2::Transform::None;
160 uint32_t z_order_ = 0;
161 android_dataspace_t dataspace_ = HAL_DATASPACE_UNKNOWN;
166 HwcDisplay(ResourceManager *resource_manager, DrmDevice *drm,
167 std::shared_ptr<Importer> importer, hwc2_display_t handle,
168 HWC2::DisplayType type);
169 HwcDisplay(const HwcDisplay &) = delete;
170 HWC2::Error Init(std::vector<DrmPlane *> *planes);
172 void RegisterVsyncCallback(hwc2_callback_data_t data,
173 hwc2_function_pointer_t func);
174 void RegisterRefreshCallback(hwc2_callback_data_t data,
175 hwc2_function_pointer_t func);
176 HWC2::Error CreateComposition(bool test);
177 bool HardwareSupportsLayerType(HWC2::Composition comp_type);
178 uint32_t CalcPixOps(std::map<uint32_t, DrmHwcTwo::HwcLayer *> &z_map,
179 size_t first_z, size_t size);
180 void MarkValidated(std::map<uint32_t, DrmHwcTwo::HwcLayer *> &z_map,
181 size_t client_first_z, size_t client_size);
188 HWC2::Error AcceptDisplayChanges();
189 HWC2::Error CreateLayer(hwc2_layer_t *layer);
190 HWC2::Error DestroyLayer(hwc2_layer_t layer);
191 HWC2::Error GetActiveConfig(hwc2_config_t *config);
192 HWC2::Error GetChangedCompositionTypes(uint32_t *num_elements,
193 hwc2_layer_t *layers,
195 HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height,
196 int32_t format, int32_t dataspace);
197 HWC2::Error GetColorModes(uint32_t *num_modes, int32_t *modes);
198 HWC2::Error GetDisplayAttribute(hwc2_config_t config, int32_t attribute,
200 HWC2::Error GetDisplayConfigs(uint32_t *num_configs,
201 hwc2_config_t *configs);
202 HWC2::Error GetDisplayName(uint32_t *size, char *name);
203 HWC2::Error GetDisplayRequests(int32_t *display_requests,
204 uint32_t *num_elements, hwc2_layer_t *layers,
205 int32_t *layer_requests);
206 HWC2::Error GetDisplayType(int32_t *type);
207 #if PLATFORM_SDK_VERSION > 27
208 HWC2::Error GetRenderIntents(int32_t mode, uint32_t *outNumIntents,
209 int32_t *outIntents);
210 HWC2::Error SetColorModeWithIntent(int32_t mode, int32_t intent);
212 #if PLATFORM_SDK_VERSION > 28
213 HWC2::Error GetDisplayIdentificationData(uint8_t *outPort,
214 uint32_t *outDataSize,
216 HWC2::Error GetDisplayCapabilities(uint32_t *outNumCapabilities,
217 uint32_t *outCapabilities);
218 HWC2::Error GetDisplayBrightnessSupport(bool *supported);
219 HWC2::Error SetDisplayBrightness(float);
221 #if PLATFORM_SDK_VERSION > 29
222 HWC2::Error GetDisplayConnectionType(uint32_t *outType);
223 HWC2::Error GetDisplayVsyncPeriod(hwc2_vsync_period_t *outVsyncPeriod);
225 HWC2::Error SetActiveConfigWithConstraints(
226 hwc2_config_t config,
227 hwc_vsync_period_change_constraints_t *vsyncPeriodChangeConstraints,
228 hwc_vsync_period_change_timeline_t *outTimeline);
229 HWC2::Error SetAutoLowLatencyMode(bool on);
230 HWC2::Error GetSupportedContentTypes(
231 uint32_t *outNumSupportedContentTypes,
232 const uint32_t *outSupportedContentTypes);
234 HWC2::Error SetContentType(int32_t contentType);
237 HWC2::Error GetDozeSupport(int32_t *support);
238 HWC2::Error GetHdrCapabilities(uint32_t *num_types, int32_t *types,
239 float *max_luminance,
240 float *max_average_luminance,
241 float *min_luminance);
242 HWC2::Error GetReleaseFences(uint32_t *num_elements, hwc2_layer_t *layers,
244 HWC2::Error PresentDisplay(int32_t *present_fence);
245 HWC2::Error SetActiveConfig(hwc2_config_t config);
246 HWC2::Error ChosePreferredConfig();
247 HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
248 int32_t dataspace, hwc_region_t damage);
249 HWC2::Error SetColorMode(int32_t mode);
250 HWC2::Error SetColorTransform(const float *matrix, int32_t hint);
251 HWC2::Error SetOutputBuffer(buffer_handle_t buffer, int32_t release_fence);
252 HWC2::Error SetPowerMode(int32_t mode);
253 HWC2::Error SetVsyncEnabled(int32_t enabled);
254 HWC2::Error ValidateDisplay(uint32_t *num_types, uint32_t *num_requests);
255 HwcLayer *get_layer(hwc2_layer_t layer) {
256 auto it = layers_.find(layer);
257 if (it == layers_.end())
264 Stats minus(Stats b) {
265 return {total_frames_ - b.total_frames_,
266 total_pixops_ - b.total_pixops_,
267 gpu_pixops_ - b.gpu_pixops_,
268 failed_kms_validate_ - b.failed_kms_validate_,
269 failed_kms_present_ - b.failed_kms_present_,
270 frames_flattened_ - b.frames_flattened_};
273 uint32_t total_frames_ = 0;
274 uint64_t total_pixops_ = 0;
275 uint64_t gpu_pixops_ = 0;
276 uint32_t failed_kms_validate_ = 0;
277 uint32_t failed_kms_present_ = 0;
278 uint32_t frames_flattened_ = 0;
281 const Backend *backend() const {
282 return backend_.get();
284 void set_backend(std::unique_ptr<Backend> backend) {
285 backend_ = std::move(backend);
288 const std::vector<DrmPlane *> &primary_planes() const {
289 return primary_planes_;
292 const std::vector<DrmPlane *> &overlay_planes() const {
293 return overlay_planes_;
296 std::map<hwc2_layer_t, HwcLayer> &layers() {
300 const DrmDisplayCompositor &compositor() const {
304 const DrmDevice *drm() const {
308 const DrmConnector *connector() const {
312 const std::shared_ptr<Importer> &importer() const {
316 ResourceManager *resource_manager() const {
317 return resource_manager_;
320 android_color_transform_t &color_transform_hint() {
321 return color_transform_hint_;
324 Stats &total_stats() {
329 void AddFenceToPresentFence(int fd);
331 constexpr static size_t MATRIX_SIZE = 16;
333 ResourceManager *resource_manager_;
335 DrmDisplayCompositor compositor_;
336 std::shared_ptr<Importer> importer_;
337 std::unique_ptr<Planner> planner_;
339 std::vector<DrmPlane *> primary_planes_;
340 std::vector<DrmPlane *> overlay_planes_;
342 std::unique_ptr<Backend> backend_;
344 VSyncWorker vsync_worker_;
345 DrmConnector *connector_ = NULL;
346 DrmCrtc *crtc_ = NULL;
347 hwc2_display_t handle_;
348 HWC2::DisplayType type_;
349 uint32_t layer_idx_ = 0;
350 std::map<hwc2_layer_t, HwcLayer> layers_;
351 HwcLayer client_layer_;
352 UniqueFd present_fence_;
353 int32_t color_mode_{};
354 std::array<float, MATRIX_SIZE> color_transform_matrix_{};
355 android_color_transform_t color_transform_hint_;
357 uint32_t frame_no_ = 0;
360 std::string DumpDelta(DrmHwcTwo::HwcDisplay::Stats delta);
363 class DrmHotplugHandler : public DrmEventHandler {
365 DrmHotplugHandler(DrmHwcTwo *hwc2, DrmDevice *drm)
366 : hwc2_(hwc2), drm_(drm) {
368 void HandleEvent(uint64_t timestamp_us);
376 static DrmHwcTwo *toDrmHwcTwo(hwc2_device_t *dev) {
377 return static_cast<DrmHwcTwo *>(dev);
380 template <typename PFN, typename T>
381 static hwc2_function_pointer_t ToHook(T function) {
382 static_assert(std::is_same<PFN, T>::value, "Incompatible fn pointer");
383 return reinterpret_cast<hwc2_function_pointer_t>(function);
386 template <typename T, typename HookType, HookType func, typename... Args>
387 static T DeviceHook(hwc2_device_t *dev, Args... args) {
388 DrmHwcTwo *hwc = toDrmHwcTwo(dev);
389 return static_cast<T>(((*hwc).*func)(std::forward<Args>(args)...));
392 static HwcDisplay *GetDisplay(DrmHwcTwo *hwc, hwc2_display_t display_handle) {
393 auto it = hwc->displays_.find(display_handle);
394 if (it == hwc->displays_.end())
400 template <typename HookType, HookType func, typename... Args>
401 static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle,
403 HwcDisplay *display = GetDisplay(toDrmHwcTwo(dev), display_handle);
405 return static_cast<int32_t>(HWC2::Error::BadDisplay);
407 return static_cast<int32_t>((display->*func)(std::forward<Args>(args)...));
410 template <typename HookType, HookType func, typename... Args>
411 static int32_t LayerHook(hwc2_device_t *dev, hwc2_display_t display_handle,
412 hwc2_layer_t layer_handle, Args... args) {
413 HwcDisplay *display = GetDisplay(toDrmHwcTwo(dev), display_handle);
415 return static_cast<int32_t>(HWC2::Error::BadDisplay);
417 HwcLayer *layer = display->get_layer(layer_handle);
419 return static_cast<int32_t>(HWC2::Error::BadLayer);
421 return static_cast<int32_t>((layer->*func)(std::forward<Args>(args)...));
424 // hwc2_device_t hooks
425 static int HookDevClose(hw_device_t *dev);
426 static void HookDevGetCapabilities(hwc2_device_t *dev, uint32_t *out_count,
427 int32_t *out_capabilities);
428 static hwc2_function_pointer_t HookDevGetFunction(struct hwc2_device *device,
432 HWC2::Error CreateVirtualDisplay(uint32_t width, uint32_t height,
433 int32_t *format, hwc2_display_t *display);
434 HWC2::Error DestroyVirtualDisplay(hwc2_display_t display);
435 void Dump(uint32_t *outSize, char *outBuffer);
436 uint32_t GetMaxVirtualDisplayCount();
437 HWC2::Error RegisterCallback(int32_t descriptor, hwc2_callback_data_t data,
438 hwc2_function_pointer_t function);
439 HWC2::Error CreateDisplay(hwc2_display_t displ, HWC2::DisplayType type);
440 void HandleDisplayHotplug(hwc2_display_t displayid, int state);
441 void HandleInitialHotplugState(DrmDevice *drmDevice);
443 ResourceManager resource_manager_;
444 std::map<hwc2_display_t, HwcDisplay> displays_;
446 std::string mDumpString;
448 } // namespace android