drmhwctwo.h

   1 /*
   2  * Copyright (C) 2016 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 #include "drmdisplaycompositor.h"
  18 #include "drmhwcomposer.h"
  19 #include "drmresources.h"
  20 #include "platform.h"
  21 #include "vsyncworker.h"
  22
  23 #include <hardware/hwcomposer2.h>
  24
  25 #include <map>
  26
  27 namespace android {
  28
  29 class DrmHwcTwo : public hwc2_device_t {
  30  public:
  31   static int HookDevOpen(const struct hw_module_t *module, const char *name,
  32                          struct hw_device_t **dev);
  33
  34   DrmHwcTwo();
  35
  36   HWC2::Error Init();
  37
  38  private:
  39   class HwcLayer {
  40    public:
  41     HWC2::Composition sf_type() const {
  42       return sf_type_;
  43     }
  44     HWC2::Composition validated_type() const {
  45       return validated_type_;
  46     }
  47     void accept_type_change() {
  48       sf_type_ = validated_type_;
  49     }
  50     void set_validated_type(HWC2::Composition type) {
  51       validated_type_ = type;
  52     }
  53     bool type_changed() const {
  54       return sf_type_ != validated_type_;
  55     }
  56
  57     uint32_t z_order() const {
  58       return z_order_;
  59     }
  60
  61     buffer_handle_t buffer() {
  62       return buffer_;
  63     }
  64     void set_buffer(buffer_handle_t buffer) {
  65       buffer_ = buffer;
  66     }
  67
  68     int take_acquire_fence() {
  69       return acquire_fence_.Release();
  70     }
  71     void set_acquire_fence(int acquire_fence) {
  72       acquire_fence_.Set(dup(acquire_fence));
  73     }
  74
  75     int release_fence() {
  76       return release_fence_.get();
  77     }
  78     int take_release_fence() {
  79       return release_fence_.Release();
  80     }
  81     void manage_release_fence() {
  82       release_fence_.Set(release_fence_raw_);
  83       release_fence_raw_ = -1;
  84     }
  85     OutputFd release_fence_output() {
  86       return OutputFd(&release_fence_raw_);
  87     }
  88
  89     void PopulateDrmLayer(DrmHwcLayer *layer);
  90
  91     // Layer hooks
  92     HWC2::Error SetCursorPosition(int32_t x, int32_t y);
  93     HWC2::Error SetLayerBlendMode(int32_t mode);
  94     HWC2::Error SetLayerBuffer(buffer_handle_t buffer, int32_t acquire_fence);
  95     HWC2::Error SetLayerColor(hwc_color_t color);
  96     HWC2::Error SetLayerCompositionType(int32_t type);
  97     HWC2::Error SetLayerDataspace(int32_t dataspace);
  98     HWC2::Error SetLayerDisplayFrame(hwc_rect_t frame);
  99     HWC2::Error SetLayerPlaneAlpha(float alpha);
 100     HWC2::Error SetLayerSidebandStream(const native_handle_t *stream);
 101     HWC2::Error SetLayerSourceCrop(hwc_frect_t crop);
 102     HWC2::Error SetLayerSurfaceDamage(hwc_region_t damage);
 103     HWC2::Error SetLayerTransform(int32_t transform);
 104     HWC2::Error SetLayerVisibleRegion(hwc_region_t visible);
 105     HWC2::Error SetLayerZOrder(uint32_t z);
 106
 107    private:
 108     // sf_type_ stores the initial type given to us by surfaceflinger,
 109     // validated_type_ stores the type after running ValidateDisplay
 110     HWC2::Composition sf_type_ = HWC2::Composition::Invalid;
 111     HWC2::Composition validated_type_ = HWC2::Composition::Invalid;
 112
 113     HWC2::BlendMode blending_ = HWC2::BlendMode::None;
 114     buffer_handle_t buffer_;
 115     UniqueFd acquire_fence_;
 116     int release_fence_raw_ = -1;
 117     UniqueFd release_fence_;
 118     hwc_rect_t display_frame_;
 119     float alpha_ = 1.0f;
 120     hwc_frect_t source_crop_;
 121     int32_t cursor_x_;
 122     int32_t cursor_y_;
 123     HWC2::Transform transform_ = HWC2::Transform::None;
 124     uint32_t z_order_ = 0;
 125     android_dataspace_t dataspace_ = HAL_DATASPACE_UNKNOWN;
 126   };
 127
 128   struct HwcCallback {
 129     HwcCallback(hwc2_callback_data_t d, hwc2_function_pointer_t f)
 130         : data(d), func(f) {
 131     }
 132     hwc2_callback_data_t data;
 133     hwc2_function_pointer_t func;
 134   };
 135
 136   class HwcDisplay {
 137    public:
 138     HwcDisplay(DrmResources *drm, std::shared_ptr<Importer> importer,
 139                const gralloc_module_t *gralloc, hwc2_display_t handle,
 140                HWC2::DisplayType type);
 141     HwcDisplay(const HwcDisplay &) = delete;
 142     HWC2::Error Init(std::vector<DrmPlane *> *planes);
 143
 144     HWC2::Error RegisterVsyncCallback(hwc2_callback_data_t data,
 145                                       hwc2_function_pointer_t func);
 146
 147     // HWC Hooks
 148     HWC2::Error AcceptDisplayChanges();
 149     HWC2::Error CreateLayer(hwc2_layer_t *layer);
 150     HWC2::Error DestroyLayer(hwc2_layer_t layer);
 151     HWC2::Error GetActiveConfig(hwc2_config_t *config);
 152     HWC2::Error GetChangedCompositionTypes(uint32_t *num_elements,
 153                                            hwc2_layer_t *layers,
 154                                            int32_t *types);
 155     HWC2::Error GetClientTargetSupport(uint32_t width, uint32_t height,
 156                                        int32_t format, int32_t dataspace);
 157     HWC2::Error GetColorModes(uint32_t *num_modes, int32_t *modes);
 158     HWC2::Error GetDisplayAttribute(hwc2_config_t config, int32_t attribute,
 159                                     int32_t *value);
 160     HWC2::Error GetDisplayConfigs(uint32_t *num_configs,
 161                                   hwc2_config_t *configs);
 162     HWC2::Error GetDisplayName(uint32_t *size, char *name);
 163     HWC2::Error GetDisplayRequests(int32_t *display_requests,
 164                                    uint32_t *num_elements, hwc2_layer_t *layers,
 165                                    int32_t *layer_requests);
 166     HWC2::Error GetDisplayType(int32_t *type);
 167     HWC2::Error GetDozeSupport(int32_t *support);
 168     HWC2::Error GetHdrCapabilities(uint32_t *num_types, int32_t *types,
 169                                    float *max_luminance,
 170                                    float *max_average_luminance,
 171                                    float *min_luminance);
 172     HWC2::Error GetReleaseFences(uint32_t *num_elements, hwc2_layer_t *layers,
 173                                  int32_t *fences);
 174     HWC2::Error PresentDisplay(int32_t *retire_fence);
 175     HWC2::Error SetActiveConfig(hwc2_config_t config);
 176     HWC2::Error SetClientTarget(buffer_handle_t target, int32_t acquire_fence,
 177                                 int32_t dataspace, hwc_region_t damage);
 178     HWC2::Error SetColorMode(int32_t mode);
 179     HWC2::Error SetColorTransform(const float *matrix, int32_t hint);
 180     HWC2::Error SetOutputBuffer(buffer_handle_t buffer, int32_t release_fence);
 181     HWC2::Error SetPowerMode(int32_t mode);
 182     HWC2::Error SetVsyncEnabled(int32_t enabled);
 183     HWC2::Error ValidateDisplay(uint32_t *num_types, uint32_t *num_requests);
 184     HwcLayer &get_layer(hwc2_layer_t layer) {
 185       return layers_.at(layer);
 186     }
 187
 188    private:
 189     void AddFenceToRetireFence(int fd);
 190
 191     DrmResources *drm_;
 192     DrmDisplayCompositor compositor_;
 193     std::shared_ptr<Importer> importer_;
 194     std::unique_ptr<Planner> planner_;
 195     const gralloc_module_t *gralloc_;
 196
 197     std::vector<DrmPlane *> primary_planes_;
 198     std::vector<DrmPlane *> overlay_planes_;
 199
 200     VSyncWorker vsync_worker_;
 201     DrmConnector *connector_ = NULL;
 202     DrmCrtc *crtc_ = NULL;
 203     hwc2_display_t handle_;
 204     HWC2::DisplayType type_;
 205     uint32_t layer_idx_ = 0;
 206     std::map<hwc2_layer_t, HwcLayer> layers_;
 207     HwcLayer client_layer_;
 208     UniqueFd retire_fence_;
 209     UniqueFd next_retire_fence_;
 210     int32_t color_mode_;
 211
 212     uint32_t frame_no_ = 0;
 213   };
 214
 215   static DrmHwcTwo *toDrmHwcTwo(hwc2_device_t *dev) {
 216     return static_cast<DrmHwcTwo *>(dev);
 217   }
 218
 219   template <typename PFN, typename T>
 220   static hwc2_function_pointer_t ToHook(T function) {
 221     static_assert(std::is_same<PFN, T>::value, "Incompatible fn pointer");
 222     return reinterpret_cast<hwc2_function_pointer_t>(function);
 223   }
 224
 225   template <typename T, typename HookType, HookType func, typename... Args>
 226   static T DeviceHook(hwc2_device_t *dev, Args... args) {
 227     DrmHwcTwo *hwc = toDrmHwcTwo(dev);
 228     return static_cast<T>(((*hwc).*func)(std::forward<Args>(args)...));
 229   }
 230
 231   template <typename HookType, HookType func, typename... Args>
 232   static int32_t DisplayHook(hwc2_device_t *dev, hwc2_display_t display_handle,
 233                              Args... args) {
 234     DrmHwcTwo *hwc = toDrmHwcTwo(dev);
 235     HwcDisplay &display = hwc->displays_.at(display_handle);
 236     return static_cast<int32_t>((display.*func)(std::forward<Args>(args)...));
 237   }
 238
 239   template <typename HookType, HookType func, typename... Args>
 240   static int32_t LayerHook(hwc2_device_t *dev, hwc2_display_t display_handle,
 241                            hwc2_layer_t layer_handle, Args... args) {
 242     DrmHwcTwo *hwc = toDrmHwcTwo(dev);
 243     HwcDisplay &display = hwc->displays_.at(display_handle);
 244     HwcLayer &layer = display.get_layer(layer_handle);
 245     return static_cast<int32_t>((layer.*func)(std::forward<Args>(args)...));
 246   }
 247
 248   // hwc2_device_t hooks
 249   static int HookDevClose(hw_device_t *dev);
 250   static void HookDevGetCapabilities(hwc2_device_t *dev, uint32_t *out_count,
 251                                      int32_t *out_capabilities);
 252   static hwc2_function_pointer_t HookDevGetFunction(struct hwc2_device *device,
 253                                                     int32_t descriptor);
 254
 255   // Device functions
 256   HWC2::Error CreateVirtualDisplay(uint32_t width, uint32_t height,
 257                                    int32_t *format,
 258                                    hwc2_display_t *display);
 259   HWC2::Error DestroyVirtualDisplay(hwc2_display_t display);
 260   void Dump(uint32_t *size, char *buffer);
 261   uint32_t GetMaxVirtualDisplayCount();
 262   HWC2::Error RegisterCallback(int32_t descriptor, hwc2_callback_data_t data,
 263                                hwc2_function_pointer_t function);
 264
 265   DrmResources drm_;
 266   std::shared_ptr<Importer> importer_;  // Shared with HwcDisplay
 267   const gralloc_module_t *gralloc_;
 268   std::map<hwc2_display_t, HwcDisplay> displays_;
 269   std::map<HWC2::Callback, HwcCallback> callbacks_;
 270 };
 271 }