Added the Panorama dynamic turn on/off feature.

Added enable/disable panorama interfaces in HWC service API for
it be able to controlled by other process for dynamic turning
on/off panorama view mode in ACRN AaaG environment.

Change-Id: Ic3e5f22d65a533132adf6752a4f93b060476d6ca
Tracked-On: https://jira.devtools.intel.com/browse/OAM-76498
Tests: Turn on/off Panorama mode dynamically on ACRN AaaG.

Signed-off-by: Wan Shuang <shuang.wan@intel.com>

diff --git a/common/core/gpudevice.cpp b/common/core/gpudevice.cpp
index 4d6808b..98a2d78 100644 (file)
--- a/common/core/gpudevice.cpp
+++ b/common/core/gpudevice.cpp
@@ -307,6 +307,7 @@ void GpuDevice::InitializePanorama(
         panorama_sos_displays.at(0).at(sos_it));
     virtualdisp->InitVirtualDisplay(1920, 1080);
     i_available_panorama_displays.emplace_back(virtualdisp);
+    virtual_panorama_displays_.emplace_back(virtualdisp);
   }
 
   // Add the native displays
@@ -330,6 +331,8 @@ void GpuDevice::InitializePanorama(
             // Skip the disconnected display here
             i_available_panorama_displays.emplace_back(
                 temp_displays.at(panorama_displays.at(m).at(l)));
+            physical_panorama_displays_.emplace_back(
+                temp_displays.at(panorama_displays.at(m).at(l)));
             // Add tag for panorama-ed displays
             available_displays.at(panorama_displays.at(m).at(l)) = false;
           }
@@ -346,14 +349,31 @@ void GpuDevice::InitializePanorama(
     std::unique_ptr<MosaicDisplay> panorama(
         new MosaicDisplay(i_available_panorama_displays));
     panorama->SetPanoramaMode(true);
-    panorama->SetExtraDispInfo((int)panorama_displays.size(),
-                               (int)panorama_sos_displays.size());
+    panorama->SetExtraDispInfo(&virtual_panorama_displays_,
+                               &physical_panorama_displays_);
+    ptr_mosaicdisplay = (MosaicDisplay *)panorama.get();
     panorama_displays_.emplace_back(std::move(panorama));
     // Save the panorama to the final displays list
     total_displays_.emplace_back(panorama_displays_.back().get());
   }
 }
 
+bool GpuDevice::TriggerPanorama(uint32_t hotplug_simulation) {
+  bool ret = false;
+  if (ptr_mosaicdisplay) {
+    ret = ptr_mosaicdisplay->TriggerPanorama(hotplug_simulation);
+  }
+  return ret;
+}
+
+bool GpuDevice::ShutdownPanorama(uint32_t hotplug_simulation) {
+  bool ret = false;
+  if (ptr_mosaicdisplay) {
+    ret = ptr_mosaicdisplay->ShutdownPanorama(hotplug_simulation);
+  }
+  return ret;
+}
+
 #endif
 
 void GpuDevice::ParseLogicalDisplaySetting(

diff --git a/common/core/mosaicdisplay.cpp b/common/core/mosaicdisplay.cpp
index d16328c..2ba5bb1 100644 (file)
--- a/common/core/mosaicdisplay.cpp
+++ b/common/core/mosaicdisplay.cpp
@@ -24,6 +24,11 @@
 
 #include "hwctrace.h"
 
+#ifdef ENABLE_PANORAMA
+#include "displaymanager.h"
+#include "virtualpanoramadisplay.h"
+#endif
+
 namespace hwcomposer {
 
 class MDVsyncCallback : public hwcomposer::VsyncCallback {
@@ -72,9 +77,30 @@ MosaicDisplay::MosaicDisplay(const std::vector<NativeDisplay *> &displays)
   for (uint32_t i = 0; i < size; i++) {
     physical_displays_.emplace_back(displays.at(i));
   }
+#ifdef ENABLE_PANORAMA
+  event_.Initialize();
+#endif
 }
 
 MosaicDisplay::~MosaicDisplay() {
+#ifdef ENABLE_PANORAMA
+  if (panorama_mode_) {
+    while (!virtual_panorama_displays_->empty()) {
+      NativeDisplay *ptr_display = virtual_panorama_displays_->back();
+      delete ptr_display;
+    }
+    while (!physical_panorama_displays_->empty()) {
+      NativeDisplay *ptr_display = physical_panorama_displays_->back();
+      delete ptr_display;
+    }
+  } else {
+    while (!physical_displays_.empty()) {
+      NativeDisplay *ptr_display = physical_displays_.back();
+      physical_displays_.pop_back();
+      delete ptr_display;
+    }
+  }
+#endif
 }
 
 bool MosaicDisplay::Initialize(NativeBufferHandler * /*buffer_handler*/) {
@@ -177,10 +203,33 @@ bool MosaicDisplay::Present(std::vector<HwcLayer *> &source_layers,
                             int32_t *retire_fence,
                             PixelUploaderCallback *call_back,
                             bool /*handle_constraints*/) {
-  if (power_mode_ != kOn)
+  if (power_mode_ != kOn) {
+#ifdef ENALBE_PANORAMA
+    if (skip_update_) {
+      event_.Signal();
+    }
+#endif
     return true;
+  }
+
+#ifdef ENABLE_PANORAMA
+  if (skip_update_) {
+    return true;
+  }
 
+  under_present = true;
+#endif
   lock_.lock();
+
+#ifdef ENABLE_PANORAMA
+  uint32_t curr_displays_num = connected_displays_.size();
+  uint32_t physical_displays_num = physical_displays_.size();
+
+  if (curr_displays_num != physical_displays_num) {
+    update_connected_displays_ = true;
+  }
+#endif
+
   if (update_connected_displays_) {
     std::vector<NativeDisplay *>().swap(connected_displays_);
     uint32_t size = physical_displays_.size();
@@ -194,6 +243,11 @@ bool MosaicDisplay::Present(std::vector<HwcLayer *> &source_layers,
   lock_.unlock();
   uint32_t size = connected_displays_.size();
   int32_t left_constraint = 0;
+#ifdef ENABLE_PANORAMA
+  if (panorama_mode_ && !panorama_enabling_state_) {
+    left_constraint += total_width_virtual_ / 2;
+  }
+#endif
   size_t total_layers = source_layers.size();
   int32_t fence = -1;
   *retire_fence = -1;
@@ -247,6 +301,13 @@ bool MosaicDisplay::Present(std::vector<HwcLayer *> &source_layers,
     left_constraint = right_constraint;
   }
 
+#ifdef ENABLE_PANORAMA
+  if (skip_update_) {
+    event_.Signal();
+  }
+  under_present = false;
+#endif
+
   return true;
 }
 
@@ -369,17 +430,34 @@ void MosaicDisplay::HotPlugUpdate(bool connected) {
   vsync_divisor_ = vsync_counter_;
 #endif
 
+#ifdef ENABLE_PANORAMA
+  if (!panorama_mode_) {
+    if (connected_ == connected) {
+      lock_.unlock();
+      return;
+    }
+  }
+#else
   if (connected_ == connected) {
     lock_.unlock();
     return;
   }
+#endif
 
   if (hotplug_callback_) {
+#ifdef ENABLE_PANORAMA
+    if (!panorama_mode_) {
+      if (!connected && connected_ && total_connected_displays) {
+        lock_.unlock();
+        return;
+      }
+    }
+#else
     if (!connected && connected_ && total_connected_displays) {
       lock_.unlock();
       return;
     }
-
+#endif
     connected_ = connected;
     hotplug_callback_->Callback(display_id_, connected);
   }
@@ -509,7 +587,15 @@ bool MosaicDisplay::GetDisplayConfigs(uint32_t *num_configs,
 
 bool MosaicDisplay::GetDisplayName(uint32_t *size, char *name) {
   std::ostringstream stream;
+#ifdef ENABLE_PANORAMA
+  if (panorama_mode_) {
+    stream << "Panorama";
+  } else {
+    stream << "Mosaic";
+  }
+#else
   stream << "Mosaic";
+#endif
   std::string string = stream.str();
   size_t length = string.length();
   if (!name) {
@@ -517,7 +603,7 @@ bool MosaicDisplay::GetDisplayName(uint32_t *size, char *name) {
     return true;
   }
 
-  *size = std::min<uint32_t>(static_cast<uint32_t>(length - 1), *size);
+  *size = std::min<uint32_t>(static_cast<uint32_t>(length), *size);
   strncpy(name, string.c_str(), *size);
   return true;
 }
@@ -548,14 +634,126 @@ bool MosaicDisplay::ContainConnector(const uint32_t connector_id) {
 
 #ifdef ENABLE_PANORAMA
 void MosaicDisplay::SetPanoramaMode(bool mode) {
+  panorama_lock_.lock();
   panorama_mode_ = mode;
+  if (panorama_mode_)
+    panorama_enabling_state_ = true;
+  panorama_lock_.unlock();
+}
+
+void MosaicDisplay::SetExtraDispInfo(
+    std::vector<NativeDisplay *> *virtual_panorama_displays,
+    std::vector<NativeDisplay *> *physical_panorama_displays) {
+  virtual_panorama_displays_ = virtual_panorama_displays;
+  physical_panorama_displays_ = physical_panorama_displays;
+
+  num_physical_displays_ = physical_panorama_displays->size();
+
+  num_virtual_displays_ = virtual_panorama_displays->size();
+
+  for (uint32_t i = 0; i < physical_panorama_displays->size(); i++) {
+    real_physical_displays_.emplace_back(physical_panorama_displays->at(i));
+    total_width_physical_ += physical_panorama_displays->at(i)->Width();
+  }
+
+  for (uint32_t i = 0; i < virtual_panorama_displays->size(); i++) {
+    total_width_virtual_ += virtual_panorama_displays->at(i)->Width();
+  }
+}
+
+bool MosaicDisplay::TriggerPanorama(uint32_t hotplug_simulation) {
+  bool ret = true;
+
+  if (!panorama_mode_) {
+    ret = false;
+  } else {
+    panorama_lock_.lock();
+    if (!panorama_enabling_state_) {
+      panorama_enabling_state_ = true;
+    } else {
+      ETRACE("Panorama mode already enabled!");
+      ret = false;
+    }
+    panorama_lock_.unlock();
+  }
+
+  if (!ret) {
+    return ret;
+  }
+
+  skip_update_ = true;
+  if (under_present) {
+    event_.Wait();
+  }
+  lock_.lock();
+  physical_displays_.swap(real_physical_displays_);
+  lock_.unlock();
+
+  SetActiveConfig(0);
+
+  uint32_t size = virtual_panorama_displays_->size();
+  for (uint32_t i = 0; i < size; i++) {
+    VirtualPanoramaDisplay *ppdisplay =
+        (VirtualPanoramaDisplay *)virtual_panorama_displays_->at(i);
+    ppdisplay->SetHyperDmaBufMode(1);
+  }
+
+  update_connected_displays_ = true;
+  if (hotplug_simulation) {
+    HotPlugUpdate(false);
+    HotPlugUpdate(true);
+  }
+  skip_update_ = false;
+  return ret;
 }
 
-void MosaicDisplay::SetExtraDispInfo(int num_physical_displays,
-                                     int num_virtual_displays) {
-  num_physical_displays_ = num_physical_displays;
-  num_virtual_displays_ = num_virtual_displays;
+bool MosaicDisplay::ShutdownPanorama(uint32_t hotplug_simulation) {
+  bool ret = true;
+
+  if (!panorama_mode_) {
+    ret = false;
+  } else {
+    panorama_lock_.lock();
+    if (panorama_enabling_state_) {
+      panorama_enabling_state_ = false;
+    } else {
+      ETRACE("Panorama mode already disabled!");
+      ret = false;
+    }
+    panorama_lock_.unlock();
+  }
+
+  if (!ret) {
+    return ret;
+  }
+
+  skip_update_ = true;
+  if (under_present) {
+    event_.Wait();
+  }
+  lock_.lock();
+
+  uint32_t size = virtual_panorama_displays_->size();
+  for (uint32_t i = 0; i < size; i++) {
+    VirtualPanoramaDisplay *ppdisplay =
+        (VirtualPanoramaDisplay *)virtual_panorama_displays_->at(i);
+    ppdisplay->SetHyperDmaBufMode(0);
+  }
+
+  physical_displays_.swap(real_physical_displays_);
+  lock_.unlock();
+
+  SetActiveConfig(0);
+
+  update_connected_displays_ = true;
+  if (hotplug_simulation) {
+    HotPlugUpdate(false);
+    HotPlugUpdate(true);
+  }
+  skip_update_ = false;
+  return ret;
 }
+
 #endif
 
 }  // namespace hwcomposer

diff --git a/common/core/mosaicdisplay.h b/common/core/mosaicdisplay.h
index 302e79b..4630e29 100644 (file)
--- a/common/core/mosaicdisplay.h
+++ b/common/core/mosaicdisplay.h
@@ -24,8 +24,12 @@
 
 #include <nativedisplay.h>
 #include <spinlock.h>
+#include "hwcevent.h"
 
 namespace hwcomposer {
+#ifdef ENABLE_PANORAMA
+class DisplayManager;
+#endif
 
 class MosaicDisplay : public NativeDisplay {
  public:
@@ -118,7 +122,11 @@ class MosaicDisplay : public NativeDisplay {
 
 #ifdef ENABLE_PANORAMA
   void SetPanoramaMode(bool mode);
-  void SetExtraDispInfo(int num_physical_displays, int num_virtual_displays);
+  void SetExtraDispInfo(
+      std::vector<NativeDisplay *> *virtual_panorama_displays,
+      std::vector<NativeDisplay *> *physical_panorama_displays);
+  bool TriggerPanorama(uint32_t hotplug_simulation);
+  bool ShutdownPanorama(uint32_t hotplug_simulation);
 #endif
 
  private:
@@ -143,9 +151,19 @@ class MosaicDisplay : public NativeDisplay {
   bool pending_vsync_ = false;
   bool update_connected_displays_ = true;
 #ifdef ENABLE_PANORAMA
+  std::vector<NativeDisplay *> *virtual_panorama_displays_;
+  std::vector<NativeDisplay *> *physical_panorama_displays_;
+  std::vector<NativeDisplay *> real_physical_displays_;
+  SpinLock panorama_lock_;
   bool panorama_mode_ = false;
+  bool panorama_enabling_state_ = false;
+  bool skip_update_ = false;
+  bool under_present = false;
   int32_t num_physical_displays_ = 1;
+  int32_t total_width_physical_ = 0;
   int32_t num_virtual_displays_ = 1;
+  int32_t total_width_virtual_ = 0;
+  HWCEvent event_;
 #endif
   SpinLock lock_;
 };

diff --git a/common/display/virtualpanoramadisplay.cpp b/common/display/virtualpanoramadisplay.cpp
index 899a22c..12d84c6 100644 (file)
--- a/common/display/virtualpanoramadisplay.cpp
+++ b/common/display/virtualpanoramadisplay.cpp
@@ -77,8 +77,10 @@ void VirtualPanoramaDisplay::InitHyperDmaBuf() {
     } else
       ITRACE("Hyper DmaBuf: IOCTL_HYPER_DMABUF_TX_CH_SETUP Done!\n");
   }
+  if (mHyperDmaBuf_Fd > 0) {
+    hyper_dmabuf_initialized = true;
+  }
 #endif
-  hyper_dmabuf_initialized = true;
 }
 
 VirtualPanoramaDisplay::~VirtualPanoramaDisplay() {
@@ -91,6 +93,7 @@ VirtualPanoramaDisplay::~VirtualPanoramaDisplay() {
     temp.handle_ = handle_;
     resource_manager_->MarkResourceForDeletion(temp, false);
   }
+
   if (output_handle_) {
     delete output_handle_;
   }
@@ -99,6 +102,13 @@ VirtualPanoramaDisplay::~VirtualPanoramaDisplay() {
   resource_manager_->PurgeBuffer();
   compositor_.Reset();
 #ifdef HYPER_DMABUF_SHARING
+  HyperDmaUnExport();
+#endif
+}
+
+#ifdef HYPER_DMABUF_SHARING
+void VirtualPanoramaDisplay::HyperDmaUnExport() {
+  HyperDmaExport(true);
   if (mHyperDmaBuf_Fd > 0) {
     auto it = mHyperDmaExportedBuffers.begin();
     for (; it != mHyperDmaExportedBuffers.end(); ++it) {
@@ -116,15 +126,17 @@ VirtualPanoramaDisplay::~VirtualPanoramaDisplay() {
       } else {
         ITRACE("Hyper DmaBuf: IOCTL_HYPER_DMABUF_UNEXPORT ioctl Done [0x%x]!\n",
                it->second.hyper_dmabuf_id.id);
-        mHyperDmaExportedBuffers.erase(it);
       }
     }
 
+    mHyperDmaExportedBuffers.clear();
+
     close(mHyperDmaBuf_Fd);
     mHyperDmaBuf_Fd = -1;
   }
-#endif
+  hyper_dmabuf_initialized = false;
 }
+#endif
 
 void VirtualPanoramaDisplay::InitVirtualDisplay(uint32_t width,
                                                 uint32_t height) {
@@ -145,7 +157,7 @@ bool VirtualPanoramaDisplay::SetActiveConfig(uint32_t /*config*/) {
   return true;
 }
 
-void VirtualPanoramaDisplay::HyperDmaExport() {
+void VirtualPanoramaDisplay::HyperDmaExport(bool notify_stopping) {
 #ifdef HYPER_DMABUF_SHARING
   int ret = 0;
   size_t buffer_number = 0;
@@ -196,12 +208,23 @@ void VirtualPanoramaDisplay::HyperDmaExport() {
       mHyperDmaExportedBuffers[imported_fd].rotation = 0;
       mHyperDmaExportedBuffers[imported_fd].status = 0;
       mHyperDmaExportedBuffers[imported_fd].counter = 0;
-      mHyperDmaExportedBuffers[imported_fd].surface_id = display_index_;
+      if (notify_stopping) {
+        // Send an invalid surface_id to let SOS daemon knowns guest is stopping
+        // sharing.
+        mHyperDmaExportedBuffers[imported_fd].surface_id = 0xff;
+      } else {
+        mHyperDmaExportedBuffers[imported_fd].surface_id = display_index_;
+      }
       mHyperDmaExportedBuffers[imported_fd].bbox[0] = 0;
       mHyperDmaExportedBuffers[imported_fd].bbox[1] = 0;
       mHyperDmaExportedBuffers[imported_fd].bbox[2] = buffer->GetWidth();
       mHyperDmaExportedBuffers[imported_fd].bbox[3] = buffer->GetHeight();
     }
+  } else {
+    if (!notify_stopping) {
+      imported_fd = buffer->GetPrimeFD();
+      mHyperDmaExportedBuffers[imported_fd].surface_id = display_index_;
+    }
   }
 
   msg.sz_priv = header_size + info_size;
@@ -229,6 +252,8 @@ void VirtualPanoramaDisplay::HyperDmaExport() {
     return;
   }
 
+  mHyperDmaExportedBuffers[buffer->GetPrimeFD()].hyper_dmabuf_id = msg.hid;
+
   resource_manager_->PreparePurgedResources();
 
   std::vector<ResourceHandle> purged_gl_resources;
@@ -281,6 +306,11 @@ bool VirtualPanoramaDisplay::Present(std::vector<HwcLayer *> &source_layers,
                                      PixelUploaderCallback * /*call_back*/,
                                      bool handle_constraints) {
   CTRACE();
+
+  if (!hyper_dmabuf_mode_) {
+    return true;
+  }
+
   if (!hyper_dmabuf_initialized) {
     InitHyperDmaBuf();
   }
@@ -374,7 +404,7 @@ bool VirtualPanoramaDisplay::Present(std::vector<HwcLayer *> &source_layers,
   }
 
 #ifdef HYPER_DMABUF_SHARING
-  HyperDmaExport();
+  HyperDmaExport(false);
 #endif
 
   return true;
@@ -492,6 +522,25 @@ int VirtualPanoramaDisplay::GetDisplayPipe() {
   return -1;
 }
 
+#ifdef HYPER_DMABUF_SHARING
+bool VirtualPanoramaDisplay::SetHyperDmaBufMode(uint32_t mode) {
+  if (hyper_dmabuf_mode_ != mode) {
+    hyper_dmabuf_mode_ = mode;
+    if (hyper_dmabuf_mode_) {
+      // Trigger hyperdmabuf sharing
+      // Disable hyper dmabuf sharing to make sure the Present method has the
+      // chance to re-establish the new hyper dmabuf channel.
+      // The purpose is to workaround SOS vmdisplay-wayland's refresh issue
+      // after resumsing from latest hyper dmabuf sharing stopping.
+      HyperDmaUnExport();
+      resource_manager_->PurgeBuffer();
+    }
+  }
+
+  return true;
+}
+#endif
+
 bool VirtualPanoramaDisplay::SetPowerMode(uint32_t /*power_mode*/) {
   return true;
 }

diff --git a/common/display/virtualpanoramadisplay.h b/common/display/virtualpanoramadisplay.h
index bc83ce9..36d76a0 100644 (file)
--- a/common/display/virtualpanoramadisplay.h
+++ b/common/display/virtualpanoramadisplay.h
@@ -61,7 +61,7 @@ class VirtualPanoramaDisplay : public NativeDisplay {
 
   void CreateOutBuffer();
 
-  void HyperDmaExport();
+  void HyperDmaExport(bool notify_stopping);
 
   DisplayType Type() const override {
     return DisplayType::kVirtual;
@@ -88,6 +88,10 @@ class VirtualPanoramaDisplay : public NativeDisplay {
 
   bool SetPowerMode(uint32_t power_mode) override;
 
+#ifdef HYPER_DMABUF_SHARING
+  bool SetHyperDmaBufMode(uint32_t mode);
+#endif
+
   int RegisterVsyncCallback(std::shared_ptr<VsyncCallback> callback,
                             uint32_t display_id) override;
 
@@ -117,10 +121,12 @@ class VirtualPanoramaDisplay : public NativeDisplay {
   bool hyper_dmabuf_initialized = false;
 
 #ifdef HYPER_DMABUF_SHARING
+  void HyperDmaUnExport();
   int mHyperDmaBuf_Fd = -1;
   std::map<uint32_t, vm_buffer_info>
       mHyperDmaExportedBuffers;  // Track the hyper dmabuf metadata info mapping
   uint32_t frame_count_ = 0;
+  uint32_t hyper_dmabuf_mode_ = 1;
 #endif
 };
 

diff --git a/os/android/hwcservice.cpp b/os/android/hwcservice.cpp
index 44511f8..b032fb5 100644 (file)
--- a/os/android/hwcservice.cpp
+++ b/os/android/hwcservice.cpp
@@ -426,6 +426,18 @@ status_t HwcService::Controls::VideoDisableAllEncryptedSessions() {
   return OK;
 }
 
+#ifdef ENABLE_PANORAMA
+status_t HwcService::Controls::TriggerPanorama(uint32_t hotplug_simulation) {
+  mHwc.TriggerPanorama(hotplug_simulation);
+  return OK;
+}
+
+status_t HwcService::Controls::ShutdownPanorama(uint32_t hotplug_simulation) {
+  mHwc.ShutdownPanorama(hotplug_simulation);
+  return OK;
+}
+#endif
+
 bool HwcService::Controls::VideoIsEncryptedSessionEnabled(uint32_t sessionID,
                                                           uint32_t instanceID) {
   // TO DO

diff --git a/os/android/hwcservice.h b/os/android/hwcservice.h
index 16192fd..481b9a2 100644 (file)
--- a/os/android/hwcservice.h
+++ b/os/android/hwcservice.h
@@ -97,6 +97,11 @@ class HwcService : public BnService {
 
     status_t DisableHDCPSessionForAllDisplays();
 
+#ifdef ENABLE_PANORAMA
+    status_t TriggerPanorama(uint32_t hotplug_simulation);
+    status_t ShutdownPanorama(uint32_t hotplug_simulation);
+#endif
+
     status_t SetHDCPSRMForAllDisplays(const int8_t* SRM, uint32_t SRMLength);
 
     status_t SetHDCPSRMForDisplay(uint32_t connector, const int8_t* SRM,

diff --git a/os/android/iahwc2.cpp b/os/android/iahwc2.cpp
index 461f4a2..abba993 100644 (file)
--- a/os/android/iahwc2.cpp
+++ b/os/android/iahwc2.cpp
@@ -85,6 +85,23 @@ class IAHotPlugEventCallback : public hwcomposer::HotPlugCallback {
 
   void Callback(uint32_t display, bool connected) {
     if (display == 0) {
+#ifdef ENABLE_PANORAMA
+      char dispname[128];
+      uint32_t size = sizeof(dispname);
+      memset(dispname, 0, sizeof(dispname));
+      display_->GetDisplayName(&size, dispname);
+      if (strstr(dispname, "Panorama")) {
+        // Allow the hotplug events to be emitted.
+      } else {
+        if (notified_) {
+          return;
+        }
+
+        if (connected) {
+          notified_ = true;
+        }
+      }
+#else
       // SF expects primary display to be always
       // connected. Let's notify it first time and ignore
       // any followup status changes.
@@ -94,6 +111,7 @@ class IAHotPlugEventCallback : public hwcomposer::HotPlugCallback {
 
       if (connected)
         notified_ = true;
+#endif
     }
 
     auto hook = reinterpret_cast<HWC2_PFN_HOTPLUG>(hook_);
@@ -1262,6 +1280,16 @@ void IAHWC2::DisableHDCPSessionForAllDisplays() {
   device_.DisableHDCPSessionForAllDisplays();
 }
 
+#ifdef ENABLE_PANORAMA
+void IAHWC2::TriggerPanorama(uint32_t hotplug_simulation) {
+  device_.TriggerPanorama(hotplug_simulation);
+}
+
+void IAHWC2::ShutdownPanorama(uint32_t hotplug_simulation) {
+  device_.ShutdownPanorama(hotplug_simulation);
+}
+#endif
+
 void IAHWC2::SetPAVPSessionStatus(bool enabled, uint32_t papv_session_id,
                                   uint32_t pavp_instance_id) {
   device_.SetPAVPSessionStatus(enabled, papv_session_id, pavp_instance_id);

diff --git a/os/android/iahwc2.h b/os/android/iahwc2.h
index 6398cc6..1062860 100644 (file)
--- a/os/android/iahwc2.h
+++ b/os/android/iahwc2.h
@@ -59,6 +59,10 @@ class IAHWC2 : public hwc2_device_t {
   void DisableHDCPSessionForDisplay(uint32_t connector);
 
   void DisableHDCPSessionForAllDisplays();
+#ifdef ENABLE_PANORAMA
+  void TriggerPanorama(uint32_t hotplug_simulation);
+  void ShutdownPanorama(uint32_t hotplug_simulation);
+#endif
 
   void SetPAVPSessionStatus(bool enabled, uint32_t pavp_session_id,
                             uint32_t pavp_instance_id);

diff --git a/os/android/libhwcservice/Android.mk b/os/android/libhwcservice/Android.mk
index 5f566eb..2e7991e 100644 (file)
--- a/os/android/libhwcservice/Android.mk
+++ b/os/android/libhwcservice/Android.mk
@@ -26,6 +26,9 @@ LOCAL_SRC_FILES += icontrols.cpp                \
 
 LOCAL_MODULE := libhwcservice
 LOCAL_CFLAGS += -fvisibility=default
+ifeq ($(strip $(ENABLE_HYPER_DMABUF_SHARING)), true)
+LOCAL_CFLAGS += -DENABLE_PANORAMA
+endif
 LOCAL_SHARED_LIBRARIES := libutils libbinder liblog
 LOCAL_MULTILIB := both
 LOCAL_EXPORT_C_INCLUDE_DIRS += $(LOCAL_PATH)

diff --git a/os/android/libhwcservice/hwcserviceapi.cpp b/os/android/libhwcservice/hwcserviceapi.cpp
index 76655e6..4596042 100644 (file)
--- a/os/android/libhwcservice/hwcserviceapi.cpp
+++ b/os/android/libhwcservice/hwcserviceapi.cpp
@@ -275,6 +275,26 @@ status_t HwcService_Video_DisableHDCPSession_ForDisplay(HWCSHANDLE hwcs,
   return pContext->mControls->DisableHDCPSessionForDisplay(connector);
 }
 
+#ifdef ENABLE_PANORAMA
+status_t HwcService_TriggerPanorama(HWCSHANDLE hwcs,
+                                    uint32_t hotplug_simulation) {
+  HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
+  if (!pContext) {
+    return android::BAD_VALUE;
+  }
+  return pContext->mControls->TriggerPanorama(hotplug_simulation);
+}
+
+status_t HwcService_ShutdownPanorama(HWCSHANDLE hwcs,
+                                     uint32_t hotplug_simulation) {
+  HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);
+  if (!pContext) {
+    return android::BAD_VALUE;
+  }
+  return pContext->mControls->ShutdownPanorama(hotplug_simulation);
+}
+#endif
+
 uint32_t HwcService_GetDisplayIDFromConnectorID(HWCSHANDLE hwcs,
                                                 uint32_t connector_id) {
   HwcsContext* pContext = static_cast<HwcsContext*>(hwcs);

diff --git a/os/android/libhwcservice/hwcserviceapi.h b/os/android/libhwcservice/hwcserviceapi.h
index 1a73de9..e0f6e2e 100644 (file)
--- a/os/android/libhwcservice/hwcserviceapi.h
+++ b/os/android/libhwcservice/hwcserviceapi.h
@@ -202,6 +202,13 @@ status_t HwcService_Video_DisableHDCPSession_ForDisplay(HWCSHANDLE hwcs,
 // on all connected displays.
 status_t HwcService_Video_DisableHDCPSession_AllDisplays(HWCSHANDLE hwcs);
 
+#ifdef ENABLE_PANORAMA
+status_t HwcService_TriggerPanorama(HWCSHANDLE hwcs,
+                                    uint32_t hotplug_simulation);
+status_t HwcService_ShutdownPanorama(HWCSHANDLE hwcs,
+                                     uint32_t hotplug_simulation);
+#endif
+
 status_t HwcService_Video_SetHDCPSRM_ForDisplay(HWCSHANDLE hwcs,
                                                 uint32_t connector,
                                                 const int8_t *SRM,

diff --git a/os/android/libhwcservice/icontrols.cpp b/os/android/libhwcservice/icontrols.cpp
index fed49f4..9a59aef 100644 (file)
--- a/os/android/libhwcservice/icontrols.cpp
+++ b/os/android/libhwcservice/icontrols.cpp
@@ -68,6 +68,10 @@ class BpControls : public BpInterface<IControls> {
     TRANSACT_MDS_UPDATE_INPUT_STATE,
     TRANSACT_WIDI_GET_SINGLE_DISPLAY,
     TRANSACT_WIDI_SET_SINGLE_DISPLAY,
+#ifdef ENABLE_PANORAMA
+    TRANSACT_TRIGGER_PANORAMA,
+    TRANSACT_SHUTDOWN_PANORAMA,
+#endif
   };
 
   status_t DisplaySetOverscan(uint32_t display, int32_t xoverscan,
@@ -110,6 +114,32 @@ class BpControls : public BpInterface<IControls> {
     return OK;
   }
 
+#ifdef ENABLE_PANORAMA
+  status_t TriggerPanorama(uint32_t hotplug_simulation) override {
+    Parcel data;
+    Parcel reply;
+    data.writeInterfaceToken(IControls::getInterfaceDescriptor());
+    data.writeInt32(hotplug_simulation);
+    status_t ret = remote()->transact(TRANSACT_TRIGGER_PANORAMA, data, &reply);
+    if (ret != NO_ERROR) {
+      ALOGW("%s() transact failed: %d", __FUNCTION__, ret);
+    }
+    return reply.readInt32();
+  }
+
+  status_t ShutdownPanorama(uint32_t hotplug_simulation) override {
+    Parcel data;
+    Parcel reply;
+    data.writeInterfaceToken(IControls::getInterfaceDescriptor());
+    data.writeInt32(hotplug_simulation);
+    status_t ret = remote()->transact(TRANSACT_SHUTDOWN_PANORAMA, data, &reply);
+    if (ret != NO_ERROR) {
+      ALOGW("%s() transact failed: %d", __FUNCTION__, ret);
+    }
+    return reply.readInt32();
+  }
+#endif
+
   status_t DisplaySetScaling(uint32_t display,
                              EHwcsScalingMode eScalingMode) override {
     Parcel data;
@@ -792,6 +822,23 @@ status_t BnControls::onTransact(uint32_t code, const Parcel &data,
       reply->writeInt32(ret);
       return NO_ERROR;
     }
+#ifdef ENABLE_PANORAMA
+    case BpControls::TRANSACT_TRIGGER_PANORAMA: {
+      CHECK_INTERFACE(IControls, data, reply);
+      uint32_t hotplug_simulation = data.readInt32();
+      status_t ret = this->TriggerPanorama(hotplug_simulation);
+      reply->writeInt32(ret);
+      return NO_ERROR;
+    }
+
+    case BpControls::TRANSACT_SHUTDOWN_PANORAMA: {
+      CHECK_INTERFACE(IControls, data, reply);
+      uint32_t hotplug_simulation = data.readInt32();
+      status_t ret = this->ShutdownPanorama(hotplug_simulation);
+      reply->writeInt32(ret);
+      return NO_ERROR;
+    }
+#endif
     case BpControls::TRANSACT_VIDEO_IS_ENCRYPTED_SESSION_ENABLED: {
       CHECK_INTERFACE(IControls, data, reply);
       uint32_t sessionID = data.readInt32();

diff --git a/os/android/libhwcservice/icontrols.h b/os/android/libhwcservice/icontrols.h
index 7efba0e..c8c0c49 100644 (file)
--- a/os/android/libhwcservice/icontrols.h
+++ b/os/android/libhwcservice/icontrols.h
@@ -65,6 +65,12 @@ class IControls : public android::IInterface {
 
   virtual status_t DisableHDCPSessionForAllDisplays() = 0;
 
+#ifdef ENABLE_PANORAMA
+  virtual status_t TriggerPanorama(uint32_t hotplug_simulation) = 0;
+
+  virtual status_t ShutdownPanorama(uint32_t hotplug_simulation) = 0;
+#endif
+
   virtual status_t SetHDCPSRMForAllDisplays(const int8_t *SRM,
                                             uint32_t SRMLength) = 0;
 

diff --git a/os/android/libhwcservice/test/Android.mk b/os/android/libhwcservice/test/Android.mk
index b0ef651..2f0f615 100644 (file)
--- a/os/android/libhwcservice/test/Android.mk
+++ b/os/android/libhwcservice/test/Android.mk
@@ -25,4 +25,7 @@ LOCAL_PROPRIETARY_MODULE := true
 ifeq ($(shell test $(ANDROID_VERSION) -ge 8; echo $$?), 0)
 LOCAL_CFLAGS += -DUSE_PROCESS_STATE
 endif
+ifeq ($(strip $(ENABLE_HYPER_DMABUF_SHARING)), true)
+LOCAL_CFLAGS += -DENABLE_PANORAMA
+endif
 include $(BUILD_EXECUTABLE)

diff --git a/os/android/libhwcservice/test/hwcservice_test.cpp b/os/android/libhwcservice/test/hwcservice_test.cpp
index fbb108b..53b8c63 100644 (file)
--- a/os/android/libhwcservice/test/hwcservice_test.cpp
+++ b/os/android/libhwcservice/test/hwcservice_test.cpp
@@ -40,7 +40,13 @@ static void usage() {
           "\t-c: Set Contrast\n"
           "\t-e: Set Sharpness\n"
           "\t-d: Set deinterlace\n"
-          "\t-r: Restore all default video colors/deinterlace \n";
+          "\t-r: Restore all default video colors/deinterlace \n"
+#ifdef ENABLE_PANORAMA
+          "\t-w: Trigger Panorama with option of hotplug simulation or not\n"
+          "\t-m: Shutdown Panorama with option of hotplug simulation or not\n";
+#else
+      ;
+#endif
   exit(-1);
 }
 
@@ -61,8 +67,16 @@ int main(int argc, char** argv) {
   bool disable_hdcp_for_display = false;
   bool disable_hdcp_for_all_display = false;
   bool restore = false;
+#ifdef ENABLE_PANORAMA
+  bool trigger_panorama = false;
+  bool shutdown_panorama = false;
+#endif
   int ch;
+#ifdef ENABLE_PANORAMA
+  while ((ch = getopt(argc, argv, "gsphijkurabcdemw")) != -1) {
+#else
   while ((ch = getopt(argc, argv, "gsphijkurabcde")) != -1) {
+#endif
     switch (ch) {
       case 'g':
         get_mode = true;
@@ -107,6 +121,14 @@ int main(int argc, char** argv) {
       case 'k':
         disable_hdcp_for_all_display = true;
         break;
+#ifdef ENABLE_PANORAMA
+      case 'w':
+        trigger_panorama = true;
+        break;
+      case 'm':
+        shutdown_panorama = true;
+        break;
+#endif
       default:
         usage();
     }
@@ -238,6 +260,29 @@ int main(int argc, char** argv) {
     HwcService_Video_DisableHDCPSession_AllDisplays(hwcs);
   }
 
+#ifdef ENABLE_PANORAMA
+  if (trigger_panorama) {
+    int simulation_hotplug = 0;
+    if (argc >= 1) {
+      simulation_hotplug = atoi(argv[0]);
+    }
+    aout << "Trigger Panorama view mode, simulation hotplug: "
+         << simulation_hotplug << endl;
+
+    HwcService_TriggerPanorama(hwcs, simulation_hotplug);
+  }
+
+  if (shutdown_panorama) {
+    int simulation_hotplug = 0;
+    if (argc >= 1) {
+      simulation_hotplug = atoi(argv[0]);
+    }
+    aout << "Shutdown Panorama view mode, simulation hotplug: "
+         << simulation_hotplug << endl;
+    HwcService_ShutdownPanorama(hwcs, simulation_hotplug);
+  }
+#endif
+
   HwcService_Disconnect(hwcs);
   return 0;
 }

diff --git a/public/gpudevice.h b/public/gpudevice.h
index 2f9d519..5d001ac 100644 (file)
--- a/public/gpudevice.h
+++ b/public/gpudevice.h
@@ -34,6 +34,9 @@
 
 namespace hwcomposer {
 
+#ifdef ENABLE_PANORAMA
+class MosaicDisplay;
+#endif
 class NativeDisplay;
 
 class GpuDevice : public HWCThread {
@@ -96,6 +99,10 @@ class GpuDevice : public HWCThread {
   void SetHDCPSRMForDisplay(uint32_t connector, const int8_t* SRM,
                             uint32_t SRMLength);
   uint32_t GetDisplayIDFromConnectorID(const uint32_t connector_id);
+#ifdef ENABLE_PANORAMA
+  bool TriggerPanorama(uint32_t hotplug_simulation);
+  bool ShutdownPanorama(uint32_t hotplug_simulation);
+#endif
 
   bool IsReservedDrmPlane();
 
@@ -137,6 +144,10 @@ class GpuDevice : public HWCThread {
       std::vector<std::vector<uint32_t>>& panorama_displays,
       std::vector<std::vector<uint32_t>>& panorama_sos_displays,
       std::vector<bool>& available_displays);
+
+  std::vector<NativeDisplay*> virtual_panorama_displays_;
+  std::vector<NativeDisplay*> physical_panorama_displays_;
+  MosaicDisplay* ptr_mosaicdisplay = NULL;
 #endif
   void ParseLogicalDisplaySetting(std::string& value,
                                   std::vector<uint32_t>& logical_displays);

diff --git a/tests/apps/panorama_disable.sh b/tests/apps/panorama_disable.sh
new file mode 100644 (file)
index 0000000..14e1c07
--- /dev/null
+++ b/tests/apps/panorama_disable.sh
@@ -0,0 +1,5 @@
+#!/system/bin/sh
+/vendor/bin/hwcservice_test -m 0
+screen_res=`/vendor/bin/hwcservice_test -g | sed -n "/^[0-9]/p" | sed -n "s/\(^[0-9]*\)[ \t]*\([0-9]*\)[ \t]*.*/\1x\2/p"`
+echo "screen_res: $screen_res"
+wm size $screen_res

diff --git a/tests/apps/panorama_enable.sh b/tests/apps/panorama_enable.sh
new file mode 100644 (file)
index 0000000..3ffe36f
--- /dev/null
+++ b/tests/apps/panorama_enable.sh
@@ -0,0 +1,5 @@
+#!/system/bin/sh
+/vendor/bin/hwcservice_test -w 0
+screen_res=`/vendor/bin/hwcservice_test -g | sed -n "/^[0-9]/p" | sed -n "s/\(^[0-9]*\)[ \t]*\([0-9]*\)[ \t]*.*/\1x\2/p"`
+echo "screen_res: $screen_res"
+wm size $screen_res