Merge "drm_hwcomposer: ground work for squashing" into mnc-dr-dev

[android-x86/external-drm_hwcomposer.git] / drmdisplaycompositor.h

diff --git a/drmdisplaycompositor.h b/drmdisplaycompositor.h
index 419960c..22e1efc 100644 (file)
--- a/drmdisplaycompositor.h
+++ b/drmdisplaycompositor.h
@@ -21,10 +21,13 @@
 #include "drmcomposition.h"
 #include "drmcompositorworker.h"
 #include "drmframebuffer.h"
+#include "seperate_rects.h"
 
 #include <pthread.h>
+#include <memory>
 #include <queue>
 #include <sstream>
+#include <tuple>
 
 #include <hardware/hardware.h>
 #include <hardware/hwcomposer.h>
@@ -35,6 +38,45 @@ namespace android {
 
 class GLWorkerCompositor;
 
+class SquashState {
+ public:
+  static const unsigned kHistoryLength = 6;
+  static const unsigned kMaxLayers = 64;
+
+  struct Region {
+    DrmHwcRect<int> rect;
+    std::bitset<kMaxLayers> layer_refs;
+    std::bitset<kHistoryLength> change_history;
+    bool squashed = false;
+  };
+
+  bool is_stable(int region_index) const {
+    return valid_history_ >= kHistoryLength &&
+           regions_[region_index].change_history.none();
+  }
+
+  const std::vector<Region> &regions() const {
+    return regions_;
+  }
+
+  void Init(DrmHwcLayer *layers, size_t num_layers);
+  void GenerateHistory(DrmHwcLayer *layers,
+                       std::vector<bool> &changed_regions) const;
+  void StableRegionsWithMarginalHistory(
+      const std::vector<bool> &changed_regions,
+      std::vector<bool> &stable_regions) const;
+  void RecordHistory(DrmHwcLayer *layers,
+                     const std::vector<bool> &changed_regions);
+  void RecordSquashed(const std::vector<bool> &squashed_regions);
+
+ private:
+  size_t generation_number_ = 0;
+  unsigned valid_history_ = 0;
+  std::vector<buffer_handle_t> last_handles_;
+
+  std::vector<Region> regions_;
+};
+
 class DrmDisplayCompositor {
  public:
   DrmDisplayCompositor();
@@ -42,12 +84,19 @@ class DrmDisplayCompositor {
 
   int Init(DrmResources *drm, int display);
 
+  std::unique_ptr<DrmDisplayComposition> CreateComposition() const;
   int QueueComposition(std::unique_ptr<DrmDisplayComposition> composition);
   int Composite();
   void Dump(std::ostringstream *out) const;
 
+  std::tuple<uint32_t, uint32_t, int> GetActiveModeResolution();
+
   bool HaveQueuedComposites() const;
 
+  SquashState *squash_state() {
+    return NULL;
+  }
+
  private:
   DrmDisplayCompositor(const DrmDisplayCompositor &) = delete;
 
@@ -56,9 +105,12 @@ class DrmDisplayCompositor {
   static const int kAcquireWaitTries = 5;
   static const int kAcquireWaitTimeoutMs = 100;
 
+  int PrepareFramebuffer(DrmFramebuffer &fb,
+                         DrmDisplayComposition *display_comp);
   int ApplyPreComposite(DrmDisplayComposition *display_comp);
   int ApplyFrame(DrmDisplayComposition *display_comp);
   int ApplyDpms(DrmDisplayComposition *display_comp);
+  int DisablePlanes(DrmDisplayComposition *display_comp);
 
   DrmResources *drm_;
   int display_;