drmhwcomposer.h

   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;
  46   DrmHwcBuffer(const hwc_drm_bo &bo, Importer *importer)
  47       : bo_(bo), importer_(importer) {
  48   }
  49   DrmHwcBuffer(DrmHwcBuffer &&rhs) : bo_(rhs.bo_), importer_(rhs.importer_) {
  50     rhs.importer_ = NULL;
  51   }
  52
  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
  84   DrmHwcNativeHandle(const gralloc_module_t *gralloc, native_handle_t *handle)
  85       : gralloc_(gralloc), handle_(handle) {
  86   }
  87
  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
 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
 155   buffer_handle_t get_usable_handle() const {
 156     return handle.get() != NULL ? handle.get() : sf_handle;
 157   }
 158
 159   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