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_DISPLAY_COMPOSITION_H_
     18 #define ANDROID_DRM_DISPLAY_COMPOSITION_H_
     19 
     20 #include "drmcrtc.h"
     21 #include "drmhwcomposer.h"
     22 #include "drmplane.h"
     23 #include "glworker.h"
     24 
     25 #include <sstream>
     26 #include <vector>
     27 
     28 #include <hardware/gralloc.h>
     29 #include <hardware/hardware.h>
     30 #include <hardware/hwcomposer.h>
     31 
     32 namespace android {
     33 
     34 class Importer;
     35 class Planner;
     36 class SquashState;
     37 
     38 enum DrmCompositionType {
     39   DRM_COMPOSITION_TYPE_EMPTY,
     40   DRM_COMPOSITION_TYPE_FRAME,
     41   DRM_COMPOSITION_TYPE_DPMS,
     42   DRM_COMPOSITION_TYPE_MODESET,
     43 };
     44 
     45 struct DrmCompositionRegion {
     46   DrmHwcRect<int> frame;
     47   std::vector<size_t> source_layers;
     48 };
     49 
     50 class DrmCompositionPlane {
     51  public:
     52   enum class Type : int32_t {
     53     kDisable,
     54     kLayer,
     55     kPrecomp,
     56     kSquash,
     57   };
     58 
     59   DrmCompositionPlane() = default;
     60   DrmCompositionPlane(DrmCompositionPlane &&rhs) = default;
     61   DrmCompositionPlane &operator=(DrmCompositionPlane &&other) = default;
     62   DrmCompositionPlane(Type type, DrmPlane *plane, DrmCrtc *crtc)
     63       : type_(type), plane_(plane), crtc_(crtc) {
     64   }
     65   DrmCompositionPlane(Type type, DrmPlane *plane, DrmCrtc *crtc,
     66                       size_t source_layer)
     67       : type_(type),
     68         plane_(plane),
     69         crtc_(crtc),
     70         source_layers_(1, source_layer) {
     71   }
     72 
     73   Type type() const {
     74     return type_;
     75   }
     76 
     77   DrmPlane *plane() const {
     78     return plane_;
     79   }
     80   void set_plane(DrmPlane *plane) {
     81     plane_ = plane;
     82   }
     83 
     84   DrmCrtc *crtc() const {
     85     return crtc_;
     86   }
     87 
     88   std::vector<size_t> &source_layers() {
     89     return source_layers_;
     90   }
     91 
     92   const std::vector<size_t> &source_layers() const {
     93     return source_layers_;
     94   }
     95 
     96  private:
     97   Type type_ = Type::kDisable;
     98   DrmPlane *plane_ = NULL;
     99   DrmCrtc *crtc_ = NULL;
    100   std::vector<size_t> source_layers_;
    101 };
    102 
    103 class DrmDisplayComposition {
    104  public:
    105   DrmDisplayComposition() = default;
    106   DrmDisplayComposition(const DrmDisplayComposition &) = delete;
    107   ~DrmDisplayComposition();
    108 
    109   int Init(DrmResources *drm, DrmCrtc *crtc, Importer *importer,
    110            Planner *planner, uint64_t frame_no);
    111 
    112   int SetLayers(DrmHwcLayer *layers, size_t num_layers, bool geometry_changed);
    113   int AddPlaneComposition(DrmCompositionPlane plane);
    114   int AddPlaneDisable(DrmPlane *plane);
    115   int SetDpmsMode(uint32_t dpms_mode);
    116   int SetDisplayMode(const DrmMode &display_mode);
    117 
    118   int Plan(SquashState *squash, std::vector<DrmPlane *> *primary_planes,
    119            std::vector<DrmPlane *> *overlay_planes);
    120 
    121   int FinalizeComposition();
    122 
    123   int CreateNextTimelineFence();
    124   int SignalSquashDone() {
    125     return IncreaseTimelineToPoint(timeline_squash_done_);
    126   }
    127   int SignalPreCompDone() {
    128     return IncreaseTimelineToPoint(timeline_pre_comp_done_);
    129   }
    130   int SignalCompositionDone() {
    131     return IncreaseTimelineToPoint(timeline_);
    132   }
    133 
    134   std::vector<DrmHwcLayer> &layers() {
    135     return layers_;
    136   }
    137 
    138   std::vector<DrmCompositionRegion> &squash_regions() {
    139     return squash_regions_;
    140   }
    141 
    142   std::vector<DrmCompositionRegion> &pre_comp_regions() {
    143     return pre_comp_regions_;
    144   }
    145 
    146   std::vector<DrmCompositionPlane> &composition_planes() {
    147     return composition_planes_;
    148   }
    149 
    150   bool geometry_changed() const {
    151     return geometry_changed_;
    152   }
    153 
    154   uint64_t frame_no() const {
    155     return frame_no_;
    156   }
    157 
    158   DrmCompositionType type() const {
    159     return type_;
    160   }
    161 
    162   uint32_t dpms_mode() const {
    163     return dpms_mode_;
    164   }
    165 
    166   const DrmMode &display_mode() const {
    167     return display_mode_;
    168   }
    169 
    170   DrmCrtc *crtc() const {
    171     return crtc_;
    172   }
    173 
    174   Importer *importer() const {
    175     return importer_;
    176   }
    177 
    178   Planner *planner() const {
    179     return planner_;
    180   }
    181 
    182   void Dump(std::ostringstream *out) const;
    183 
    184  private:
    185   bool validate_composition_type(DrmCompositionType desired);
    186 
    187   int IncreaseTimelineToPoint(int point);
    188 
    189   int FinalizeComposition(DrmHwcRect<int> *exclude_rects,
    190                           size_t num_exclude_rects);
    191   void SeparateLayers(DrmHwcRect<int> *exclude_rects, size_t num_exclude_rects);
    192   int CreateAndAssignReleaseFences();
    193 
    194   DrmResources *drm_ = NULL;
    195   DrmCrtc *crtc_ = NULL;
    196   Importer *importer_ = NULL;
    197   Planner *planner_ = NULL;
    198 
    199   DrmCompositionType type_ = DRM_COMPOSITION_TYPE_EMPTY;
    200   uint32_t dpms_mode_ = DRM_MODE_DPMS_ON;
    201   DrmMode display_mode_;
    202 
    203   int timeline_fd_ = -1;
    204   int timeline_ = 0;
    205   int timeline_current_ = 0;
    206   int timeline_squash_done_ = 0;
    207   int timeline_pre_comp_done_ = 0;
    208 
    209   bool geometry_changed_;
    210   std::vector<DrmHwcLayer> layers_;
    211   std::vector<DrmCompositionRegion> squash_regions_;
    212   std::vector<DrmCompositionRegion> pre_comp_regions_;
    213   std::vector<DrmCompositionPlane> composition_planes_;
    214 
    215   uint64_t frame_no_ = 0;
    216 };
    217 }
    218 
    219 #endif  // ANDROID_DRM_DISPLAY_COMPOSITION_H_
    220