OSDN Git Service

drm_hwcomposer: Add platform backend for minigbm
[android-x86/external-drm_hwcomposer.git] / drmdisplaycomposition.h
index 814ca24..9183925 100644 (file)
 #ifndef ANDROID_DRM_DISPLAY_COMPOSITION_H_
 #define ANDROID_DRM_DISPLAY_COMPOSITION_H_
 
-#include "drm_hwcomposer.h"
 #include "drmcrtc.h"
+#include "drmhwcomposer.h"
 #include "drmplane.h"
 #include "glworker.h"
-#include "importer.h"
 
+#include <sstream>
 #include <vector>
 
 #include <hardware/gralloc.h>
@@ -31,7 +31,9 @@
 
 namespace android {
 
-struct SquashState;
+class Importer;
+class Planner;
+class SquashState;
 
 enum DrmCompositionType {
   DRM_COMPOSITION_TYPE_EMPTY,
@@ -40,19 +42,72 @@ enum DrmCompositionType {
   DRM_COMPOSITION_TYPE_MODESET,
 };
 
+struct DrmCompositionDisplayLayersMap {
+  int display;
+  bool geometry_changed = true;
+  std::vector<DrmHwcLayer> layers;
+
+  DrmCompositionDisplayLayersMap() = default;
+  DrmCompositionDisplayLayersMap(DrmCompositionDisplayLayersMap &&rhs) =
+      default;
+};
+
 struct DrmCompositionRegion {
   DrmHwcRect<int> frame;
   std::vector<size_t> source_layers;
 };
 
-struct DrmCompositionPlane {
-  const static size_t kSourceNone = SIZE_MAX;
-  const static size_t kSourcePreComp = kSourceNone - 1;
-  const static size_t kSourceSquash = kSourcePreComp - 1;
-  const static size_t kSourceLayerMax = kSourceSquash - 1;
-  DrmPlane *plane;
-  DrmCrtc *crtc;
-  size_t source_layer;
+class DrmCompositionPlane {
+ public:
+  enum class Type : int32_t {
+    kDisable,
+    kLayer,
+    kPrecomp,
+    kSquash,
+  };
+
+  DrmCompositionPlane() = default;
+  DrmCompositionPlane(DrmCompositionPlane &&rhs) = default;
+  DrmCompositionPlane &operator=(DrmCompositionPlane &&other) = default;
+  DrmCompositionPlane(Type type, DrmPlane *plane, DrmCrtc *crtc)
+      : type_(type), plane_(plane), crtc_(crtc) {
+  }
+  DrmCompositionPlane(Type type, DrmPlane *plane, DrmCrtc *crtc,
+                      size_t source_layer)
+      : type_(type),
+        plane_(plane),
+        crtc_(crtc),
+        source_layers_(1, source_layer) {
+  }
+
+  Type type() const {
+    return type_;
+  }
+
+  DrmPlane *plane() const {
+    return plane_;
+  }
+  void set_plane(DrmPlane *plane) {
+    plane_ = plane;
+  }
+
+  DrmCrtc *crtc() const {
+    return crtc_;
+  }
+
+  std::vector<size_t> &source_layers() {
+    return source_layers_;
+  }
+
+  const std::vector<size_t> &source_layers() const {
+    return source_layers_;
+  }
+
+ private:
+  Type type_ = Type::kDisable;
+  DrmPlane *plane_ = NULL;
+  DrmCrtc *crtc_ = NULL;
+  std::vector<size_t> source_layers_;
 };
 
 class DrmDisplayComposition {
@@ -62,9 +117,10 @@ class DrmDisplayComposition {
   ~DrmDisplayComposition();
 
   int Init(DrmResources *drm, DrmCrtc *crtc, Importer *importer,
-           uint64_t frame_no);
+           Planner *planner, uint64_t frame_no);
 
-  int SetLayers(DrmHwcLayer *layers, size_t num_layers);
+  int SetLayers(DrmHwcLayer *layers, size_t num_layers, bool geometry_changed);
+  int AddPlaneComposition(DrmCompositionPlane plane);
   int AddPlaneDisable(DrmPlane *plane);
   int SetDpmsMode(uint32_t dpms_mode);
   int SetDisplayMode(const DrmMode &display_mode);
@@ -72,6 +128,8 @@ class DrmDisplayComposition {
   int Plan(SquashState *squash, std::vector<DrmPlane *> *primary_planes,
            std::vector<DrmPlane *> *overlay_planes);
 
+  int FinalizeComposition();
+
   int CreateNextTimelineFence();
   int SignalSquashDone() {
     return IncreaseTimelineToPoint(timeline_squash_done_);
@@ -99,6 +157,10 @@ class DrmDisplayComposition {
     return composition_planes_;
   }
 
+  bool geometry_changed() const {
+    return geometry_changed_;
+  }
+
   uint64_t frame_no() const {
     return frame_no_;
   }
@@ -123,14 +185,34 @@ class DrmDisplayComposition {
     return importer_;
   }
 
+  Planner *planner() const {
+    return planner_;
+  }
+
+  int take_out_fence() {
+    return out_fence_.Release();
+  }
+
+  void set_out_fence(int out_fence) {
+    out_fence_.Set(out_fence);
+  }
+
+  void Dump(std::ostringstream *out) const;
+
  private:
   bool validate_composition_type(DrmCompositionType desired);
 
   int IncreaseTimelineToPoint(int point);
 
+  int FinalizeComposition(DrmHwcRect<int> *exclude_rects,
+                          size_t num_exclude_rects);
+  void SeparateLayers(DrmHwcRect<int> *exclude_rects, size_t num_exclude_rects);
+  int CreateAndAssignReleaseFences();
+
   DrmResources *drm_ = NULL;
   DrmCrtc *crtc_ = NULL;
   Importer *importer_ = NULL;
+  Planner *planner_ = NULL;
 
   DrmCompositionType type_ = DRM_COMPOSITION_TYPE_EMPTY;
   uint32_t dpms_mode_ = DRM_MODE_DPMS_ON;
@@ -141,7 +223,9 @@ class DrmDisplayComposition {
   int timeline_current_ = 0;
   int timeline_squash_done_ = 0;
   int timeline_pre_comp_done_ = 0;
+  UniqueFd out_fence_ = -1;
 
+  bool geometry_changed_;
   std::vector<DrmHwcLayer> layers_;
   std::vector<DrmCompositionRegion> squash_regions_;
   std::vector<DrmCompositionRegion> pre_comp_regions_;