From 0fe50340f594d1bcf30d95e273602461fc60ca51 Mon Sep 17 00:00:00 2001
From: Kalyan Kondapally <kalyan.kondapally@intel.com>
Date: Sat, 16 Dec 2017 16:54:47 -0800
Subject: [PATCH] Add support to copy common displayplanestates between frames.

We now need to copy source rect, display frame, cursor state,
plane scalar state. Let's have a handy function which can do all
this rather than manually setting them in Display Queue.

Jira: None.
Test: No new regressions in Android.

Signed-off-by: Kalyan Kondapally <kalyan.kondapally@intel.com>
---
 common/display/displayplanestate.h | 48 +++++++++++++-------------------------
 common/display/displayqueue.cpp    | 23 +++++-------------
 2 files changed, 22 insertions(+), 49 deletions(-)

diff --git a/common/display/displayplanestate.h b/common/display/displayplanestate.h
index d74b188..47959da 100644
--- a/common/display/displayplanestate.h
+++ b/common/display/displayplanestate.h
@@ -20,9 +20,10 @@
 #include <stdint.h>
 #include <vector>
 
-#include "overlaylayer.h"
 #include "compositionregion.h"
+#include "displayplane.h"
 #include "nativesurface.h"
+#include "overlaylayer.h"
 
 namespace hwcomposer {
 
@@ -50,7 +51,17 @@ class DisplayPlaneState {
     }
   }
 
-  explicit DisplayPlaneState(DisplayPlane *plane) : plane_(plane) {
+  void CopyState(DisplayPlaneState &state) {
+    has_cursor_layer_ = state.has_cursor_layer_;
+    type_ = state.type_;
+    use_plane_scalar_ = state.use_plane_scalar_;
+    plane_ = state.plane_;
+    state_ = state.state_;
+    source_crop_ = state.source_crop_;
+    display_frame_ = state.display_frame_;
+    plane_->SetInUse(true);
+    // We don't copy recycled_surface_ state as this
+    // should be determined in DisplayQueue for every frame.
   }
 
   State GetCompositionState() const {
@@ -91,28 +102,13 @@ class DisplayPlaneState {
     }
   }
 
-  void AddLayers(const std::vector<size_t> &source_layers,
-                 const HwcRect<int> &display_frame, State state) {
-    size_t size = source_layers.size();
-    source_layers_.reserve(size);
-    for (const int &index : source_layers) {
-      source_layers_.emplace_back(index);
-    }
-
-    display_frame_ = display_frame;
-    state_ = state;
-    type_ = PlaneType::kNormal;
-    has_cursor_layer_ = false;
-  }
-
   // This API should be called only when Cursor layer is being
   // added, is part of layers displayed by plane or is being
   // removed in this frame. AddLayers should be used in all
   // other cases.
-  void AddLayersForCursor(const std::vector<size_t> &source_layers,
-                          const std::vector<OverlayLayer> &layers,
-                          const HwcRect<int> &display_frame, State state,
-                          bool ignore_cursor_layer) {
+  void AddLayers(const std::vector<size_t> &source_layers,
+                 const std::vector<OverlayLayer> &layers,
+                 bool ignore_cursor_layer) {
     if (ignore_cursor_layer) {
       size_t lsize = layers.size();
       size_t size = source_layers.size();
@@ -139,23 +135,11 @@ class DisplayPlaneState {
 
         source_layers_.emplace_back(index);
       }
-
-      type_ = PlaneType::kNormal;
     } else {
-      display_frame_ = display_frame;
       for (const int &index : source_layers) {
         source_layers_.emplace_back(index);
       }
-
-      has_cursor_layer_ = true;
-      if (source_layers_.size() == 1) {
-        type_ = PlaneType::kCursor;
-      } else {
-        type_ = PlaneType::kNormal;
-      }
     }
-
-    state_ = state;
   }
 
   void UpdateDisplayFrame(const HwcRect<int> &display_frame) {
diff --git a/common/display/displayqueue.cpp b/common/display/displayqueue.cpp
index d530470..8715352 100644
--- a/common/display/displayqueue.cpp
+++ b/common/display/displayqueue.cpp
@@ -147,25 +147,12 @@ void DisplayQueue::GetCachedLayers(const std::vector<OverlayLayer>& layers,
     }
 
     bool clear_surface = false;
-    composition->emplace_back(plane.plane());
+    composition->emplace_back();
     DisplayPlaneState& last_plane = composition->back();
-    last_plane.plane()->SetInUse(true);
-    bool has_cursor_layer = plane.HasCursorLayer();
-    if (has_cursor_layer) {
-      last_plane.AddLayersForCursor(
-          plane.source_layers(), layers, plane.GetDisplayFrame(),
-          plane.GetCompositionState(), cursor_layer_removed);
-
-      clear_surface = cursor_layer_removed;
-    } else {
-      last_plane.AddLayers(plane.source_layers(), plane.GetDisplayFrame(),
-                           plane.GetCompositionState());
-    }
+    last_plane.CopyState(plane);
+    last_plane.AddLayers(plane.source_layers(), layers, cursor_layer_removed);
 
-    if (plane.IsVideoPlane()) {
-      last_plane.SetVideoPlane();
-      last_plane.SetSourceCrop(plane.GetSourceCrop());
-    }
+    clear_surface = cursor_layer_removed;
 
     if (plane_state_render || plane.SurfaceRecycled()) {
       bool content_changed = false;
@@ -251,6 +238,8 @@ void DisplayQueue::GetCachedLayers(const std::vector<OverlayLayer>& layers,
           display_plane_manager_->SetOffScreenPlaneTarget(last_plane);
         }
 
+        // We always call this here to handle case where we recycled
+        // offscreen surface for last commit.
         last_plane.ForceGPURendering();
         needs_gpu_composition = true;
       } else {
-- 
2.11.0