Home | History | Annotate | Download | only in drm_hwcomposer 
      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 
    148   UniqueFd acquire_fence;
    149   OutputFd release_fence;
    150 
    151   int InitFromHwcLayer(hwc_layer_1_t *sf_layer, Importer *importer,
    152                        const gralloc_module_t *gralloc);
    153   int ImportBuffer(Importer *importer, const gralloc_module_t *gralloc);
    154 
    155   void SetTransform(int32_t sf_transform);
    156   void SetSourceCrop(hwc_frect_t const &crop);
    157   void SetDisplayFrame(hwc_rect_t const &frame);
    158 
    159   buffer_handle_t get_usable_handle() const {
    160     return handle.get() != NULL ? handle.get() : sf_handle;
    161   }
    162 
    163   bool protected_usage() const {
    164     return (gralloc_buffer_usage & GRALLOC_USAGE_PROTECTED) ==
    165            GRALLOC_USAGE_PROTECTED;
    166   }
    167 };
    168 
    169 struct DrmHwcDisplayContents {
    170   OutputFd retire_fence;
    171   std::vector<DrmHwcLayer> layers;
    172 };
    173 }
    174 
    175 #endif
    176