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 #ifndef ANDROID_DRM_HWCOMPOSER_H_ 18 #define ANDROID_DRM_HWCOMPOSER_H_ 19 20 #include <stdbool.h> 21 #include <stdint.h> 22 23 #include <hardware/hardware.h> 24 #include <hardware/hwcomposer.h> 25 #include "autofd.h" 26 #include "separate_rects.h" 27 #include "drmhwcgralloc.h" 28 29 struct hwc_import_context; 30 31 int hwc_import_init(struct hwc_import_context **ctx); 32 int hwc_import_destroy(struct hwc_import_context *ctx); 33 34 int hwc_import_bo_create(int fd, struct hwc_import_context *ctx, 35 buffer_handle_t buf, struct hwc_drm_bo *bo); 36 bool hwc_import_bo_release(int fd, struct hwc_import_context *ctx, 37 struct hwc_drm_bo *bo); 38 39 namespace android { 40 41 class Importer; 42 43 class DrmHwcBuffer { 44 public: 45 DrmHwcBuffer() = default; DrmHwcBuffer(const hwc_drm_bo & bo,Importer * importer)46 DrmHwcBuffer(const hwc_drm_bo &bo, Importer *importer) 47 : bo_(bo), importer_(importer) { 48 } DrmHwcBuffer(DrmHwcBuffer && rhs)49 DrmHwcBuffer(DrmHwcBuffer &&rhs) : bo_(rhs.bo_), importer_(rhs.importer_) { 50 rhs.importer_ = NULL; 51 } 52 ~DrmHwcBuffer()53 ~DrmHwcBuffer() { 54 Clear(); 55 } 56 57 DrmHwcBuffer &operator=(DrmHwcBuffer &&rhs) { 58 Clear(); 59 importer_ = rhs.importer_; 60 rhs.importer_ = NULL; 61 bo_ = rhs.bo_; 62 return *this; 63 } 64 65 operator bool() const { 66 return importer_ != NULL; 67 } 68 69 const hwc_drm_bo *operator->() const; 70 71 void Clear(); 72 73 int ImportBuffer(buffer_handle_t handle, Importer *importer); 74 75 private: 76 hwc_drm_bo bo_; 77 Importer *importer_ = NULL; 78 }; 79 80 class DrmHwcNativeHandle { 81 public: 82 DrmHwcNativeHandle() = default; 83 DrmHwcNativeHandle(const gralloc_module_t * gralloc,native_handle_t * handle)84 DrmHwcNativeHandle(const gralloc_module_t *gralloc, native_handle_t *handle) 85 : gralloc_(gralloc), handle_(handle) { 86 } 87 DrmHwcNativeHandle(DrmHwcNativeHandle && rhs)88 DrmHwcNativeHandle(DrmHwcNativeHandle &&rhs) { 89 gralloc_ = rhs.gralloc_; 90 rhs.gralloc_ = NULL; 91 handle_ = rhs.handle_; 92 rhs.handle_ = NULL; 93 } 94 95 ~DrmHwcNativeHandle(); 96 97 DrmHwcNativeHandle &operator=(DrmHwcNativeHandle &&rhs) { 98 Clear(); 99 gralloc_ = rhs.gralloc_; 100 rhs.gralloc_ = NULL; 101 handle_ = rhs.handle_; 102 rhs.handle_ = NULL; 103 return *this; 104 } 105 106 int CopyBufferHandle(buffer_handle_t handle, const gralloc_module_t *gralloc); 107 108 void Clear(); 109 get()110 buffer_handle_t get() const { 111 return handle_; 112 } 113 114 private: 115 const gralloc_module_t *gralloc_ = NULL; 116 native_handle_t *handle_ = NULL; 117 }; 118 119 template <typename T> 120 using DrmHwcRect = separate_rects::Rect<T>; 121 122 enum DrmHwcTransform { 123 kIdentity = 0, 124 kFlipH = 1 << 0, 125 kFlipV = 1 << 1, 126 kRotate90 = 1 << 2, 127 kRotate180 = 1 << 3, 128 kRotate270 = 1 << 4, 129 }; 130 131 enum class DrmHwcBlending : int32_t { 132 kNone = HWC_BLENDING_NONE, 133 kPreMult = HWC_BLENDING_PREMULT, 134 kCoverage = HWC_BLENDING_COVERAGE, 135 }; 136 137 struct DrmHwcLayer { 138 buffer_handle_t sf_handle = NULL; 139 int gralloc_buffer_usage = 0; 140 DrmHwcBuffer buffer; 141 DrmHwcNativeHandle handle; 142 uint32_t transform; 143 DrmHwcBlending blending = DrmHwcBlending::kNone; 144 uint8_t alpha = 0xff; 145 DrmHwcRect<float> source_crop; 146 DrmHwcRect<int> display_frame; 147 std::vector<DrmHwcRect<int>> source_damage; 148 149 UniqueFd acquire_fence; 150 OutputFd release_fence; 151 152 int InitFromHwcLayer(hwc_layer_1_t *sf_layer, Importer *importer, 153 const gralloc_module_t *gralloc); 154 get_usable_handleDrmHwcLayer155 buffer_handle_t get_usable_handle() const { 156 return handle.get() != NULL ? handle.get() : sf_handle; 157 } 158 protected_usageDrmHwcLayer159 bool protected_usage() const { 160 return (gralloc_buffer_usage & GRALLOC_USAGE_PROTECTED) == 161 GRALLOC_USAGE_PROTECTED; 162 } 163 }; 164 165 struct DrmHwcDisplayContents { 166 OutputFd retire_fence; 167 std::vector<DrmHwcLayer> layers; 168 }; 169 } 170 171 #endif 172