Implement the 2.4 new Vsync Callback for Mosaic

Without the implementation of new Vsync API. SurfaceFlinger
will crash in init once mosaic is enabled.
This one should be part of the implementation of HAL2.4.

Remaining issue: need check LogicDisplay, PanoramaDisplay and so on.
All of them need to support the new API.

Change-Id: I3f602343a9dcf097444bd832b4f6a53cf7af4a36
Tracked-On: OAM-96194
Signed-off-by: Shaofeng Tang <shaofeng.tang@intel.com>

Author: Shao-Feng

common/core/mosaicdisplay.cpp

@@ -44,6 +44,20 @@ class MDVsyncCallback : public hwcomposer::VsyncCallback {
   MosaicDisplay *display_;
 };
 
+class MDVsyncPeriodCallback : public hwcomposer::VsyncPeriodCallback {
+ public:
+  MDVsyncPeriodCallback(MosaicDisplay *display) : display_(display) {
+  }
+
+  void Callback(uint32_t display, int64_t timestamp,
+                uint32_t vsyncPeriodNanos) {
+    display_->VSyncPeriodUpdate(timestamp, vsyncPeriodNanos);
+  }
+
+ private:
+  MosaicDisplay *display_;
+};
+
 class MDRefreshCallback : public hwcomposer::RefreshCallback {
  public:
   MDRefreshCallback(MosaicDisplay *display) : display_(display) {
@@ -330,6 +344,21 @@ int MosaicDisplay::RegisterVsyncCallback(
   return 0;
 }
 
+int MosaicDisplay::RegisterVsyncPeriodCallback(
+    std::shared_ptr<VsyncPeriodCallback> callback, uint32_t display_id) {
+  display_id_ = display_id;
+  vsync_period_callback_ = callback;
+
+  uint32_t size = physical_displays_.size();
+  auto v_callback = std::make_shared<MDVsyncPeriodCallback>(this);
+  for (uint32_t i = 0; i < size; i++) {
+    physical_displays_.at(i)->RegisterVsyncPeriodCallback(
+        v_callback, physical_displays_.at(i)->GetDisplayPipe());
+  }
+
+  return 0;
+}
+
 void MosaicDisplay::RegisterRefreshCallback(
     std::shared_ptr<RefreshCallback> callback, uint32_t display_id) {
   display_id_ = display_id;
@@ -389,6 +418,27 @@ void MosaicDisplay::VSyncUpdate(int64_t timestamp) {
   lock_.unlock();
 }
 
+void MosaicDisplay::VSyncPeriodUpdate(int64_t timestamp,
+                                      uint32_t vsyncPeriodNanos) {
+  lock_.lock();
+  if (vsync_period_callback_ && enable_vsync_ && vsync_divisor_ > 0) {
+    vsync_counter_--;
+    vsync_timestamp_ += timestamp;
+    if (vsync_counter_ == 0) {
+      vsync_timestamp_ /= vsync_divisor_;
+      vsync_period_callback_->Callback(display_id_, vsync_timestamp_,
+                                       vsyncPeriodNanos);
+      vsync_counter_ = vsync_divisor_;
+      vsync_timestamp_ = 0;
+      pending_vsync_ = false;
+    } else {
+      pending_vsync_ = true;
+    }
+  }
+
+  lock_.unlock();
+}
+
 void MosaicDisplay::RefreshUpdate() {
   if (connected_ && refresh_callback_ && power_mode_ == kOn) {
     refresh_callback_->Callback(display_id_);
@@ -574,6 +624,11 @@ bool MosaicDisplay::GetDisplayAttribute(uint32_t /*config*/,
   return status;
 }
 
+bool MosaicDisplay::GetDisplayVsyncPeriod(uint32_t *outVsyncPeriod) {
+  return GetDisplayAttribute(config_, HWCDisplayAttribute::kRefreshRate,
+                             reinterpret_cast<int32_t *>(outVsyncPeriod));
+}
+
 bool MosaicDisplay::GetDisplayConfigs(uint32_t *num_configs,
                                       uint32_t *configs) {
   if (!num_configs)

common/core/mosaicdisplay.h

@@ -61,6 +61,9 @@ class MosaicDisplay : public NativeDisplay {
   int RegisterVsyncCallback(std::shared_ptr<VsyncCallback> callback,
                             uint32_t display_id) override;
 
+  int RegisterVsyncPeriodCallback(std::shared_ptr<VsyncPeriodCallback> callback,
+                                  uint32_t display_id) override;
+
   void RegisterRefreshCallback(std::shared_ptr<RefreshCallback> callback,
                                uint32_t display_id) override;
 
@@ -95,6 +98,8 @@ class MosaicDisplay : public NativeDisplay {
   bool GetDisplayAttribute(uint32_t /*config*/, HWCDisplayAttribute attribute,
                            int32_t *value) override;
 
+  bool GetDisplayVsyncPeriod(uint32_t *outVsyncPeriod) override;
+
   bool GetDisplayConfigs(uint32_t *num_configs, uint32_t *configs) override;
   bool GetDisplayName(uint32_t *size, char *name) override;
 
@@ -117,6 +122,8 @@ class MosaicDisplay : public NativeDisplay {
 
   void VSyncUpdate(int64_t timestamp);
 
+  void VSyncPeriodUpdate(int64_t timestamp, uint32_t vsyncPeriodNanos);
+
   void RefreshUpdate();
 
   void HotPlugUpdate(bool connected);
@@ -141,6 +148,7 @@ class MosaicDisplay : public NativeDisplay {
   std::vector<NativeDisplay *> connected_displays_;
   std::shared_ptr<RefreshCallback> refresh_callback_ = NULL;
   std::shared_ptr<VsyncCallback> vsync_callback_ = NULL;
+  std::shared_ptr<VsyncPeriodCallback> vsync_period_callback_ = NULL;
   std::shared_ptr<HotPlugCallback> hotplug_callback_ = NULL;
   int32_t dpix_;
   int32_t dpiy_;

public/nativedisplay.h

@@ -104,7 +104,10 @@ class NativeDisplay {
   virtual void GetDisplayCapabilities(uint32_t *outNumCapabilities,
                                       uint32_t *outCapabilities) = 0;
   virtual bool GetDisplayVsyncPeriod(uint32_t *outVsyncPeriod) {
-    return false;
+    // TODO implement this method in all displays
+    // FTB, return 16ms by default.
+    *outVsyncPeriod = 16666666;
+    return true;
   };
 
   /**