#include <gpudevice.h>
+#include <sys/file.h>
+
#include "mosaicdisplay.h"
#include "hwctrace.h"
}
bool GpuDevice::Initialize() {
- if (initialization_state_ & kInitialized)
+ initialization_state_lock_.lock();
+ if (initialization_state_ & kInitialized) {
+ initialization_state_lock_.unlock();
return true;
-
- bool use_thread = true;
- if (!InitWorker()) {
- ETRACE("Failed to initalize thread for GpuDevice. %s", PRINTERROR());
- use_thread = false;
}
- thread_stage_lock_.lock();
- display_manager_.reset(DisplayManager::CreateDisplayManager());
+ initialization_state_ |= kInitialized;
+ initialization_state_lock_.unlock();
+
+ display_manager_.reset(DisplayManager::CreateDisplayManager(this));
bool success = display_manager_->Initialize();
if (!success) {
- thread_stage_lock_.unlock();
return false;
}
- thread_stage_lock_.unlock();
- HandleHWCSettings();
- InitializeHotPlugEvents(false);
+ display_manager_->InitializeDisplayResources();
+ display_manager_->StartHotPlugMonitor();
- // Take the lock to ensure everything is initilized in
- // Handle Routine.
- thread_sync_lock_.lock();
- initialization_state_ |= kInitialized;
- initialization_state_ &= ~kHWCSettingsDone;
- // TODO: Add splash screen support.
- display_manager_->InitializeExternalLockMonitor();
- thread_sync_lock_.unlock();
+ HandleHWCSettings();
- if (use_thread) {
- // Exit thread as we don't need worker thread after
- // Initialization.
- HWCThread::Exit();
+ lock_fd_ = open("/vendor/hwc.lock", O_RDONLY);
+ if (-1 != lock_fd_) {
+ if (!InitWorker()) {
+ ETRACE("Failed to initalize thread for GpuDevice. %s", PRINTERROR());
+ }
+ } else {
+ ITRACE("Failed to open " LOCK_DIR_PREFIX "/hwc.lock file!");
}
return true;
}
+uint32_t GpuDevice::GetFD() const {
+ return display_manager_->GetFD();
+}
+
NativeDisplay *GpuDevice::GetDisplay(uint32_t display_id) {
if (total_displays_.size() > display_id)
return total_displays_.at(display_id);
return NULL;
}
-NativeDisplay *GpuDevice::GetVirtualDisplay() {
- return display_manager_->GetVirtualDisplay();
+NativeDisplay *GpuDevice::CreateVirtualDisplay(uint32_t display_index) {
+ return display_manager_->CreateVirtualDisplay(display_index);
}
-// It's for nested display
-NativeDisplay *GpuDevice::GetNestedDisplay() {
- return display_manager_->GetNestedDisplay();
+void GpuDevice::DestroyVirtualDisplay(uint32_t display_index) {
+ display_manager_->DestroyVirtualDisplay(display_index);
}
void GpuDevice::GetConnectedPhysicalDisplays(
}
}
-std::vector<NativeDisplay *> GpuDevice::GetAllDisplays() {
+const std::vector<NativeDisplay *> &GpuDevice::GetAllDisplays() {
return total_displays_;
}
}
void GpuDevice::HandleHWCSettings() {
- initialization_state_lock_.lock();
- if ((initialization_state_ & kHWCSettingsInProgress) ||
- (initialization_state_ & kHWCSettingsDone)) {
- initialization_state_lock_.unlock();
- return;
- }
-
- initialization_state_ |= kHWCSettingsInProgress;
- initialization_state_lock_.unlock();
// Handle config file reading
- const char *hwc_dp_cfg_path = std::getenv("HWC_DISPLAY_CONFIG");
- if (!hwc_dp_cfg_path) {
- hwc_dp_cfg_path = "/vendor/etc/hwc_display.ini";
- }
+ const char *hwc_dp_cfg_path = HWC_DISPLAY_INI_PATH;
+ ITRACE("Hwc display config file is %s", hwc_dp_cfg_path);
bool use_logical = false;
bool use_mosaic = false;
bool use_cloned = false;
bool rotate_display = false;
+ bool use_float = false;
std::vector<uint32_t> logical_displays;
std::vector<uint32_t> physical_displays;
std::vector<uint32_t> display_rotation;
+ std::vector<uint32_t> float_display_indices;
+ std::vector<HwcRect<int32_t>> float_displays;
std::vector<std::vector<uint32_t>> cloned_displays;
std::vector<std::vector<uint32_t>> mosaic_displays;
std::ifstream fin(hwc_dp_cfg_path);
std::string key_mosaic("MOSAIC");
std::string key_clone("CLONE");
std::string key_rotate("ROTATION");
+ std::string key_float("FLOAT");
std::string key_logical_display("LOGICAL_DISPLAY");
std::string key_mosaic_display("MOSAIC_DISPLAY");
std::string key_physical_display("PHYSICAL_DISPLAY");
std::string key_physical_display_rotation("PHYSICAL_DISPLAY_ROTATION");
std::string key_clone_display("CLONE_DISPLAY");
+ std::string key_float_display("FLOAT_DISPLAY");
std::vector<uint32_t> mosaic_duplicate_check;
std::vector<uint32_t> clone_duplicate_check;
std::vector<uint32_t> physical_duplicate_check;
if (!value.compare(enable_str)) {
rotate_display = true;
}
+ // Got float switch
+ } else if (!key.compare(key_float)) {
+ if (!value.compare(enable_str)) {
+ use_float = true;
+ }
} else if (!key.compare(key_logical_display)) {
std::string physical_index_str;
std::istringstream i_value(value);
uint32_t rotation_num = atoi(rotation_str.c_str());
display_rotation.emplace_back(rotation_num);
rotation_display_index.emplace_back(physical_index);
+ } else if (!key.compare(key_float_display)) {
+ std::string index_str;
+ std::string float_rect_str;
+ std::vector<int32_t> float_rect;
+ std::istringstream i_value(value);
+
+ // Got display index
+ std::getline(i_value, index_str, ':');
+ if (index_str.empty() ||
+ index_str.find_first_not_of("0123456789") != std::string::npos) {
+ continue;
+ }
+
+ int32_t index = atoi(index_str.c_str());
+
+ // Got rectangle configuration
+ while (std::getline(i_value, float_rect_str, '+')) {
+ if (float_rect_str.empty() ||
+ float_rect_str.find_first_not_of("0123456789") !=
+ std::string::npos) {
+ continue;
+ }
+ size_t float_rect_val = atoi(float_rect_str.c_str());
+
+ // Save the rectangle - left, top, right & bottom
+ float_rect.emplace_back(float_rect_val);
+ }
+
+ // If entire rect is available, store the parameters
+ // TODO remove hard code
+ if (float_rect.size() == 4) {
+ float_display_indices.emplace_back(index);
+ HwcRect<int32_t> rect =
+ HwcRect<int32_t>(float_rect.at(0), float_rect.at(1),
+ float_rect.at(2), float_rect.at(3));
+ float_displays.emplace_back(rect);
+ }
}
}
}
};
- InitializeHotPlugEvents();
std::vector<NativeDisplay *> displays;
std::vector<NativeDisplay *> unordered_displays =
display_manager_->GetAllDisplays();
size_t size = unordered_displays.size();
+ uint32_t dispmgr_display_size = (uint32_t) size;
if (physical_displays.empty()) {
displays.swap(unordered_displays);
} else {
size = physical_displays.size();
for (size_t i = 0; i < size; i++) {
- displays.emplace_back(unordered_displays.at(physical_displays.at(i)));
+ uint32_t pdisp_index = physical_displays.at(i);
+ // Add the physical display only if it has been enumerated from DRM API.
+ // Skip the non-existence display defined in hwc_display.ini file.
+ if (pdisp_index < dispmgr_display_size) {
+ displays.emplace_back(unordered_displays.at(pdisp_index));
+ } else {
+ ETRACE(
+ "Physical display number: %u defined in hwc_display.ini "
+ "doesn't exist in enumerated DRM display list (total: %u).",
+ pdisp_index, dispmgr_display_size);
+ }
}
if (displays.size() != unordered_displays.size()) {
temp_displays.swap(total_displays_);
}
- initialization_state_lock_.lock();
- initialization_state_ &= ~kHWCSettingsInProgress;
- initialization_state_ |= kHWCSettingsDone;
- initialization_state_lock_.unlock();
+ // Now set floating display configuration
+ // Get the floating display index and the respective rectangle
+ // TODO Logical display on & mosaic display on scenario
+ if (use_float && !use_logical && !use_mosaic) {
+ bool ret = false;
+ size_t size = float_display_indices.size();
+ size_t num_displays = total_displays_.size();
+
+ // Set custom resolution to desired display instance
+ for (size_t i = 0; i < size; i++) {
+ int index = float_display_indices.at(i);
+
+ // Ignore float index if out of range of connected displays
+ if ((size_t)index < num_displays) {
+ const HwcRect<int32_t> &rect = float_displays.at(i);
+ ret = total_displays_.at(index)->SetCustomResolution(rect);
+ }
+ }
+ }
}
-void GpuDevice::InitializeHotPlugEvents(bool take_lock) {
- initialization_state_lock_.lock();
- if ((initialization_state_ & kInitializeHotPlugMonitor) ||
- (initialization_state_ & kInitializedHotPlugMonitor)) {
- initialization_state_lock_.unlock();
+void GpuDevice::EnableHDCPSessionForDisplay(uint32_t display,
+ HWCContentType content_type) {
+ if (total_displays_.size() <= display) {
+ ETRACE("Tried to enable HDCP for invalid display %u \n", display);
return;
}
- initialization_state_ |= kInitializeHotPlugMonitor;
- if (take_lock) {
- // Take a lock to ensure displaymanager is all initialized.
- thread_stage_lock_.lock();
+ NativeDisplay *native_display = total_displays_.at(display);
+ native_display->SetHDCPState(HWCContentProtection::kDesired, content_type);
+}
+
+void GpuDevice::EnableHDCPSessionForAllDisplays(HWCContentType content_type) {
+ size_t size = total_displays_.size();
+ for (size_t i = 0; i < size; i++) {
+ total_displays_.at(i)
+ ->SetHDCPState(HWCContentProtection::kDesired, content_type);
}
- display_manager_->InitializeDisplayResources();
- display_manager_->StartHotPlugMonitor();
- if (take_lock)
- thread_stage_lock_.unlock();
+}
- initialization_state_ |= kInitializedHotPlugMonitor;
- initialization_state_lock_.unlock();
+void GpuDevice::DisableHDCPSessionForDisplay(uint32_t display) {
+ if (total_displays_.size() <= display) {
+ ETRACE("Tried to enable HDCP for invalid display %u \n", display);
+ return;
+ }
+
+ NativeDisplay *native_display = total_displays_.at(display);
+ native_display->SetHDCPState(HWCContentProtection::kUnDesired,
+ HWCContentType::kInvalid);
+}
+
+void GpuDevice::DisableHDCPSessionForAllDisplays() {
+ size_t size = total_displays_.size();
+ for (size_t i = 0; i < size; i++) {
+ total_displays_.at(i)->SetHDCPState(HWCContentProtection::kUnDesired,
+ HWCContentType::kInvalid);
+ }
+}
+
+void GpuDevice::SetPAVPSessionStatus(bool enabled, uint32_t pavp_session_id,
+ uint32_t pavp_instance_id) {
+ size_t size = total_displays_.size();
+ for (size_t i = 0; i < size; i++) {
+ total_displays_.at(i)->SetPAVPSessionStatus(enabled, pavp_session_id,
+ pavp_instance_id);
+ }
+}
+
+void GpuDevice::SetHDCPSRMForAllDisplays(const int8_t *SRM,
+ uint32_t SRMLength) {
+ size_t size = total_displays_.size();
+ for (size_t i = 0; i < size; i++) {
+ total_displays_.at(i)->SetHDCPSRM(SRM, SRMLength);
+ }
+}
+
+void GpuDevice::SetHDCPSRMForDisplay(uint32_t display, const int8_t *SRM,
+ uint32_t SRMLength) {
+ if (total_displays_.size() <= display) {
+ ETRACE("Tried to enable HDCP for invalid display %u \n", display);
+ return;
+ }
+
+ NativeDisplay *native_display = total_displays_.at(display);
+ native_display->SetHDCPSRM(SRM, SRMLength);
}
void GpuDevice::HandleRoutine() {
- thread_sync_lock_.lock();
- HandleHWCSettings();
- thread_sync_lock_.unlock();
+ bool update_ignored = false;
+
+ // Iniitialize resources to monitor external events.
+ // These can be two types:
+ // 1) We are showing splash screen and another App
+ // needs to take the control. In this case splash
+ // is true.
+ // 2) Another app is having control of display and we
+ // we need to take control.
+ // TODO: Add splash screen support.
+ if (lock_fd_ != -1) {
+ display_manager_->IgnoreUpdates();
+ update_ignored = true;
+
+ if (flock(lock_fd_, LOCK_EX) != 0) {
+ ETRACE("Failed to wait on the hwc lock.");
+ } else {
+ ITRACE("Successfully grabbed the hwc lock.");
+ }
+
+ display_manager_->setDrmMaster();
+
+ close(lock_fd_);
+ lock_fd_ = -1;
+ }
+
+ if (update_ignored)
+ display_manager_->ForceRefresh();
+}
+
+void GpuDevice::HandleWait() {
+ if (lock_fd_ == -1) {
+ HWCThread::HandleWait();
+ }
+}
+
+void GpuDevice::DisableWatch() {
+ HWCThread::Exit();
}
} // namespace hwcomposer
OSDN Git Service
