Merge "sde: Change the secure buffer alignment requirement"
diff --git a/displayengine/include/core/display_interface.h b/displayengine/include/core/display_interface.h
index c041e1a..3042eb2 100644
--- a/displayengine/include/core/display_interface.h
+++ b/displayengine/include/core/display_interface.h
@@ -95,13 +95,13 @@
uint32_t y_pixels; //!< Total number of pixels in Y-direction on the display panel.
float x_dpi; //!< Dots per inch in X-direction.
float y_dpi; //!< Dots per inch in Y-direction.
- float fps; //!< Frame rate per second.
+ uint32_t fps; //!< Frame rate per second.
uint32_t vsync_period_ns; //!< VSync period in nanoseconds.
- uint32_t v_total; //!< Total lines in Y-direction (vActive + vFP + vBP + vPulseWidth).
+ uint32_t v_total; //!< Total height of panel (vActive + vFP + vBP + vPulseWidth).
uint32_t h_total; //!< Total width of panel (hActive + hFP + hBP + hPulseWidth).
DisplayConfigVariableInfo() : x_pixels(0), y_pixels(0), x_dpi(0.0f), y_dpi(0.0f),
- fps(0.0f), vsync_period_ns(0), v_total(0), h_total(0) { }
+ fps(0), vsync_period_ns(0), v_total(0), h_total(0) { }
};
/*! @brief Event data associated with VSync event.
@@ -334,6 +334,27 @@
*/
virtual DisplayError SetDisplayMode(uint32_t mode) = 0;
+ /*! @brief Method to determine whether scaling for a custom resolution is valid.
+
+ @return \link DisplayError \endlink
+ */
+ virtual DisplayError IsScalingValid(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90) = 0;
+
+ /*! @brief Method to set the refresh rate of a display.
+
+ @param[in] new refresh rate of the display.
+
+ @return \link DisplayError \endlink
+ */
+ virtual DisplayError SetRefreshRate(uint32_t refresh_rate) = 0;
+
+ /*! @brief Method to query whether scanning is support for the HDMI display.
+
+ @return \link DisplayError \endlink
+ */
+ virtual bool IsUnderscanSupported() = 0;
+
protected:
virtual ~DisplayInterface() { }
};
diff --git a/displayengine/include/private/hw_info_types.h b/displayengine/include/private/hw_info_types.h
index 1740615..03a77ae 100644
--- a/displayengine/include/private/hw_info_types.h
+++ b/displayengine/include/private/hw_info_types.h
@@ -106,6 +106,24 @@
kPortEDP,
};
+/*! @brief This enumeration holds the all possible scan types. */
+enum HWScanSupport {
+ kScanNotSupported,
+ kScanAlwaysOverscanned,
+ kScanAlwaysUnderscanned,
+ kScanBoth,
+};
+
+/*! @brief This structure holds the scan support for different timing modes. */
+struct HWScanInfo {
+ HWScanSupport pt_scan_support; //!< Scan support for preferred timing
+ HWScanSupport it_scan_support; //!< Scan support for digital monitor or industry timings
+ HWScanSupport cea_scan_support; //!< Scan support for CEA resolution timings
+
+ HWScanInfo() : pt_scan_support(kScanNotSupported), it_scan_support(kScanNotSupported),
+ cea_scan_support(kScanNotSupported) { }
+};
+
/*! @brief This structure describes the split configuration of a display panel. */
struct HWSplitInfo {
uint32_t left_split;
@@ -113,6 +131,15 @@
bool always_src_split;
HWSplitInfo() : left_split(0), right_split(0), always_src_split(false) { }
+
+ bool operator !=(const HWSplitInfo &split_info) {
+ return ((left_split != split_info.left_split) || (right_split != split_info.right_split) ||
+ (always_src_split != split_info.always_src_split));
+ }
+
+ bool operator ==(const HWSplitInfo &split_info) {
+ return !(operator !=(split_info));
+ }
};
/*! @brief This structure describes properties of a display panel. */
@@ -136,6 +163,23 @@
HWPanelInfo() : port(kPortDefault), mode(kModeDefault), partial_update(false), left_align(false),
width_align(false), top_align(false), height_align(false), min_roi_width(0), min_roi_height(0),
needs_roi_merge(false), dynamic_fps(false), min_fps(0), max_fps(0) { }
+
+ bool operator !=(const HWPanelInfo &panel_info) {
+ return ((port != panel_info.port) || (mode != panel_info.mode) ||
+ (partial_update != panel_info.partial_update) ||
+ (left_align != panel_info.left_align) || (width_align != panel_info.width_align) ||
+ (top_align != panel_info.top_align) || (height_align != panel_info.height_align) ||
+ (min_roi_width != panel_info.min_roi_width) ||
+ (min_roi_height != panel_info.min_roi_height) ||
+ (needs_roi_merge != panel_info.needs_roi_merge) ||
+ (dynamic_fps != panel_info.dynamic_fps) || (min_fps != panel_info.min_fps) ||
+ (max_fps != panel_info.max_fps) || (is_primary_panel != panel_info.is_primary_panel) ||
+ (split_info != panel_info.split_info));
+ }
+
+ bool operator ==(const HWPanelInfo &panel_info) {
+ return !(operator !=(panel_info));
+ }
};
} // namespace sde
diff --git a/displayengine/include/private/strategy_interface.h b/displayengine/include/private/strategy_interface.h
index df01c7f..a0a52f8 100644
--- a/displayengine/include/private/strategy_interface.h
+++ b/displayengine/include/private/strategy_interface.h
@@ -96,7 +96,7 @@
@return \link DisplayError \endlink
*/
typedef DisplayError (*CreateStrategyInterface)(uint16_t version, DisplayType type,
- const HWResourceInfo *hw_resource_info, const HWPanelInfo *hw_panel_info,
+ const HWResourceInfo &hw_resource_info, const HWPanelInfo &hw_panel_info,
StrategyInterface **interface);
/*! @brief Function to destroy composer strategy interface.
diff --git a/displayengine/include/utils/debug.h b/displayengine/include/utils/debug.h
index 2cef5d7..1dbf0c3 100644
--- a/displayengine/include/utils/debug.h
+++ b/displayengine/include/utils/debug.h
@@ -65,7 +65,7 @@
static uint32_t GetIdleTimeoutMs();
static bool IsRotatorDownScaleDisabled();
static bool IsDecimationDisabled();
- static bool IsPartialUpdate();
+ static bool IsPartialUpdateEnabled();
private:
Debug();
diff --git a/displayengine/libs/core/comp_manager.cpp b/displayengine/libs/core/comp_manager.cpp
index 82f7b8d..fa02e94 100644
--- a/displayengine/libs/core/comp_manager.cpp
+++ b/displayengine/libs/core/comp_manager.cpp
@@ -107,7 +107,7 @@
return kErrorMemory;
}
- if (create_strategy_intf_(STRATEGY_VERSION_TAG, type, &hw_res_info_, &hw_panel_info,
+ if (create_strategy_intf_(STRATEGY_VERSION_TAG, type, hw_res_info_, hw_panel_info,
&display_comp_ctx->strategy_intf) != kErrorNone) {
DLOGW("Unable to create strategy interface");
delete display_comp_ctx;
@@ -165,6 +165,16 @@
return kErrorNone;
}
+void CompManager::ReconfigureDisplay(Handle comp_handle, const HWDisplayAttributes &attributes,
+ const HWPanelInfo &hw_panel_info) {
+ DisplayCompositionContext *display_comp_ctx =
+ reinterpret_cast<DisplayCompositionContext *>(comp_handle);
+
+ res_mgr_.ReconfigureDisplay(display_comp_ctx->display_resource_ctx, attributes, hw_panel_info);
+
+ // TODO(user): Need to reconfigure strategy with updated panel info
+}
+
void CompManager::PrepareStrategyConstraints(Handle comp_handle, HWLayers *hw_layers) {
DisplayCompositionContext *display_comp_ctx =
reinterpret_cast<DisplayCompositionContext *>(comp_handle);
@@ -351,5 +361,10 @@
SCOPE_LOCK(locker_);
}
+DisplayError CompManager::ValidateScaling(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90) {
+ return res_mgr_.ValidateScaling(crop, dst, rotate90);
+}
+
} // namespace sde
diff --git a/displayengine/libs/core/comp_manager.h b/displayengine/libs/core/comp_manager.h
index ae638e0..88f4b3e 100644
--- a/displayengine/libs/core/comp_manager.h
+++ b/displayengine/libs/core/comp_manager.h
@@ -41,6 +41,8 @@
DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
const HWPanelInfo &hw_panel_info, Handle *res_mgr_hnd);
DisplayError UnregisterDisplay(Handle res_mgr_hnd);
+ void ReconfigureDisplay(Handle display_ctx, const HWDisplayAttributes &attributes,
+ const HWPanelInfo &hw_panel_info);
void PrePrepare(Handle display_ctx, HWLayers *hw_layers);
DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
DisplayError PostPrepare(Handle display_ctx, HWLayers *hw_layers);
@@ -49,6 +51,7 @@
bool ProcessIdleTimeout(Handle display_ctx);
void ProcessThermalEvent(Handle display_ctx, int64_t thermal_level);
DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages);
+ DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst, bool rotate90);
// DumpImpl method
virtual void AppendDump(char *buffer, uint32_t length);
diff --git a/displayengine/libs/core/display_base.cpp b/displayengine/libs/core/display_base.cpp
index 47beac0..b64eae7 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -41,7 +41,7 @@
buffer_sync_handler_(buffer_sync_handler), comp_manager_(comp_manager),
rotator_ctrl_(rotator_ctrl), state_(kStateOff), hw_device_(0), display_comp_ctx_(0),
display_attributes_(NULL), num_modes_(0), active_mode_index_(0), pending_commit_(false),
- vsync_enable_(false) {
+ vsync_enable_(false), underscan_supported_(false) {
}
DisplayError DisplayBase::Init() {
@@ -290,6 +290,10 @@
return kErrorNone;
}
+bool DisplayBase::IsUnderscanSupported() {
+ return underscan_supported_;
+}
+
DisplayError DisplayBase::SetDisplayState(DisplayState state) {
DisplayError error = kErrorNone;
@@ -339,36 +343,6 @@
return error;
}
-DisplayError DisplayBase::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
- DisplayError error = kErrorNone;
-
- if (!variable_info) {
- return kErrorParameters;
- }
-
- HWDisplayAttributes display_attributes = display_attributes_[active_mode_index_];
-
- display_attributes.x_pixels = variable_info->x_pixels;
- display_attributes.y_pixels = variable_info->y_pixels;
- display_attributes.fps = variable_info->fps;
-
- // if display is already connected, unregister display from composition manager and register
- // the display with new configuration.
- if (display_comp_ctx_) {
- comp_manager_->UnregisterDisplay(display_comp_ctx_);
- }
-
- error = comp_manager_->RegisterDisplay(display_type_, display_attributes, hw_panel_info_,
- &display_comp_ctx_);
- if (error != kErrorNone) {
- return error;
- }
-
- display_attributes_[active_mode_index_] = display_attributes;
-
- return kErrorNone;
-}
-
DisplayError DisplayBase::SetActiveConfig(uint32_t index) {
DisplayError error = kErrorNone;
@@ -407,6 +381,11 @@
return kErrorNotSupported;
}
+DisplayError DisplayBase::IsScalingValid(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90) {
+ return comp_manager_->ValidateScaling(crop, dst, rotate90);
+}
+
void DisplayBase::AppendDump(char *buffer, uint32_t length) {
DumpImpl::AppendString(buffer, length, "\n-----------------------");
DumpImpl::AppendString(buffer, length, "\ndevice type: %u", display_type_);
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 0a33011..ef1ea1f 100644
--- a/displayengine/libs/core/display_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -55,10 +55,11 @@
virtual DisplayError GetActiveConfig(uint32_t *index);
virtual DisplayError GetVSyncState(bool *enabled);
virtual DisplayError SetDisplayState(DisplayState state);
- virtual DisplayError SetActiveConfig(DisplayConfigVariableInfo *variable_info);
virtual DisplayError SetActiveConfig(uint32_t index);
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual DisplayError SetDisplayMode(uint32_t mode);
+ virtual DisplayError IsScalingValid(const LayerRect &crop, const LayerRect &dst, bool rotate90);
+ virtual bool IsUnderscanSupported();
protected:
// DumpImpl method
@@ -87,6 +88,7 @@
HWLayers hw_layers_;
bool pending_commit_;
bool vsync_enable_;
+ bool underscan_supported_;
};
} // namespace sde
diff --git a/displayengine/libs/core/display_hdmi.cpp b/displayengine/libs/core/display_hdmi.cpp
index 65ea21f..a36f2f2 100644
--- a/displayengine/libs/core/display_hdmi.cpp
+++ b/displayengine/libs/core/display_hdmi.cpp
@@ -60,6 +60,9 @@
HWHDMIInterface::Destroy(hw_hdmi_intf_);
}
+ GetScanSupport();
+ underscan_supported_ = (scan_support_ == kScanAlwaysUnderscanned) || (scan_support_ == kScanBoth);
+
return error;
}
@@ -127,7 +130,7 @@
DisplayError DisplayHDMI::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
SCOPE_LOCK(locker_);
- return DisplayBase::SetActiveConfig(variable_info);
+ return kErrorNotSupported;
}
DisplayError DisplayHDMI::SetActiveConfig(uint32_t index) {
@@ -152,6 +155,22 @@
return DisplayBase::SetDisplayMode(mode);
}
+DisplayError DisplayHDMI::IsScalingValid(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::IsScalingValid(crop, dst, rotate90);
+}
+
+DisplayError DisplayHDMI::SetRefreshRate(uint32_t refresh_rate) {
+ SCOPE_LOCK(locker_);
+ return kErrorNotSupported;
+}
+
+bool DisplayHDMI::IsUnderscanSupported() {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::IsUnderscanSupported();
+}
+
int DisplayHDMI::GetBestConfig() {
uint32_t best_config_mode = 0;
HWDisplayAttributes *best = &display_attributes_[0];
@@ -193,6 +212,36 @@
return best_config_mode;
}
+void DisplayHDMI::GetScanSupport() {
+ DisplayError error = kErrorNone;
+ uint32_t video_format = -1;
+ uint32_t max_cea_format = -1;
+ HWScanInfo scan_info = HWScanInfo();
+ hw_hdmi_intf_->GetHWScanInfo(&scan_info);
+
+ error = hw_hdmi_intf_->GetVideoFormat(active_mode_index_, &video_format);
+ if (error != kErrorNone) {
+ return;
+ }
+
+ error = hw_hdmi_intf_->GetMaxCEAFormat(&max_cea_format);
+ if (error != kErrorNone) {
+ return;
+ }
+
+ // The scan support for a given HDMI TV must be read from scan info corresponding to
+ // Preferred Timing if the preferred timing of the display is currently active, and if it is
+ // valid. In all other cases, we must read the scan support from CEA scan info if
+ // the resolution is a CEA resolution, or from IT scan info for all other resolutions.
+ if (active_mode_index_ == 0 && scan_info.pt_scan_support != kScanNotSupported) {
+ scan_support_ = scan_info.pt_scan_support;
+ } else if (video_format < max_cea_format) {
+ scan_support_ = scan_info.cea_scan_support;
+ } else {
+ scan_support_ = scan_info.it_scan_support;
+ }
+}
+
void DisplayHDMI::AppendDump(char *buffer, uint32_t length) {
SCOPE_LOCK(locker_);
DisplayBase::AppendDump(buffer, length);
diff --git a/displayengine/libs/core/display_hdmi.h b/displayengine/libs/core/display_hdmi.h
index ea1b80c..b5a25cc 100644
--- a/displayengine/libs/core/display_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -56,14 +56,19 @@
virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual DisplayError SetDisplayMode(uint32_t mode);
+ virtual DisplayError IsScalingValid(const LayerRect &crop, const LayerRect &dst, bool rotate90);
+ virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
+ virtual bool IsUnderscanSupported();
virtual void AppendDump(char *buffer, uint32_t length);
private:
virtual int GetBestConfig();
+ virtual void GetScanSupport();
Locker locker_;
HWHDMIInterface *hw_hdmi_intf_;
HWInfoInterface *hw_info_intf_;
+ HWScanSupport scan_support_;
};
} // namespace sde
diff --git a/displayengine/libs/core/display_primary.cpp b/displayengine/libs/core/display_primary.cpp
index 0fa5d2b..faea0da 100644
--- a/displayengine/libs/core/display_primary.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -88,14 +88,25 @@
DisplayError DisplayPrimary::Commit(LayerStack *layer_stack) {
SCOPE_LOCK(locker_);
DisplayError error = kErrorNone;
+ HWPanelInfo panel_info;
+ HWDisplayAttributes display_attributes;
error = DisplayBase::Commit(layer_stack);
if (error != kErrorNone) {
return error;
}
- hw_primary_intf_->GetHWPanelInfo(&hw_panel_info_);
- // TODO(user): Update panel info in composition manager and resource manager
+ hw_primary_intf_->GetHWPanelInfo(&panel_info);
+
+ hw_primary_intf_->GetDisplayAttributes(&display_attributes, active_mode_index_);
+
+ if (panel_info != hw_panel_info_ ||
+ display_attributes != display_attributes_[active_mode_index_]) {
+ comp_manager_->ReconfigureDisplay(display_comp_ctx_, display_attributes, panel_info);
+
+ hw_panel_info_ = panel_info;
+ display_attributes_[active_mode_index_] = display_attributes;
+ }
return error;
}
@@ -135,6 +146,11 @@
return DisplayBase::GetVSyncState(enabled);
}
+bool DisplayPrimary::IsUnderscanSupported() {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::IsUnderscanSupported();
+}
+
DisplayError DisplayPrimary::SetDisplayState(DisplayState state) {
SCOPE_LOCK(locker_);
return DisplayBase::SetDisplayState(state);
@@ -142,7 +158,7 @@
DisplayError DisplayPrimary::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
SCOPE_LOCK(locker_);
- return DisplayBase::SetActiveConfig(variable_info);
+ return kErrorNotSupported;
}
DisplayError DisplayPrimary::SetActiveConfig(uint32_t index) {
@@ -214,13 +230,37 @@
return error;
}
+DisplayError DisplayPrimary::IsScalingValid(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::IsScalingValid(crop, dst, rotate90);
+}
+
+DisplayError DisplayPrimary::SetRefreshRate(uint32_t refresh_rate) {
+ SCOPE_LOCK(locker_);
+
+ DisplayError error = kErrorNone;
+
+ if (!hw_panel_info_.dynamic_fps) {
+ DLOGW("Dynamic fps feature is not supported");
+ return kErrorNotSupported;
+ }
+
+ if (refresh_rate > hw_panel_info_.max_fps) {
+ refresh_rate = hw_panel_info_.max_fps;
+ } else if (refresh_rate < hw_panel_info_.min_fps) {
+ refresh_rate = hw_panel_info_.min_fps;
+ }
+
+ return hw_primary_intf_->SetRefreshRate(refresh_rate);
+}
+
void DisplayPrimary::AppendDump(char *buffer, uint32_t length) {
SCOPE_LOCK(locker_);
DisplayBase::AppendDump(buffer, length);
}
DisplayError DisplayPrimary::VSync(int64_t timestamp) {
- SCOPE_LOCK(locker_);
if (vsync_enable_) {
DisplayEventVSync vsync;
vsync.timestamp = timestamp;
diff --git a/displayengine/libs/core/display_primary.h b/displayengine/libs/core/display_primary.h
index 1ed28b2..11f9687 100644
--- a/displayengine/libs/core/display_primary.h
+++ b/displayengine/libs/core/display_primary.h
@@ -56,6 +56,9 @@
virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual DisplayError SetDisplayMode(uint32_t mode);
+ virtual DisplayError IsScalingValid(const LayerRect &crop, const LayerRect &dst, bool rotate90);
+ virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
+ virtual bool IsUnderscanSupported();
virtual void AppendDump(char *buffer, uint32_t length);
// Implement the HWEventHandlers
diff --git a/displayengine/libs/core/display_virtual.cpp b/displayengine/libs/core/display_virtual.cpp
index 5480f0e..30588dc 100644
--- a/displayengine/libs/core/display_virtual.cpp
+++ b/displayengine/libs/core/display_virtual.cpp
@@ -120,6 +120,11 @@
return DisplayBase::GetVSyncState(enabled);
}
+bool DisplayVirtual::IsUnderscanSupported() {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::IsUnderscanSupported();
+}
+
DisplayError DisplayVirtual::SetDisplayState(DisplayState state) {
SCOPE_LOCK(locker_);
return DisplayBase::SetDisplayState(state);
@@ -127,7 +132,33 @@
DisplayError DisplayVirtual::SetActiveConfig(DisplayConfigVariableInfo *variable_info) {
SCOPE_LOCK(locker_);
- return DisplayBase::SetActiveConfig(variable_info);
+ DisplayError error = kErrorNone;
+
+ if (!variable_info) {
+ return kErrorParameters;
+ }
+
+ HWDisplayAttributes display_attributes = display_attributes_[active_mode_index_];
+
+ display_attributes.x_pixels = variable_info->x_pixels;
+ display_attributes.y_pixels = variable_info->y_pixels;
+ display_attributes.fps = variable_info->fps;
+
+ // if display is already connected, unregister display from composition manager and register
+ // the display with new configuration.
+ if (display_comp_ctx_) {
+ comp_manager_->UnregisterDisplay(display_comp_ctx_);
+ }
+
+ error = comp_manager_->RegisterDisplay(display_type_, display_attributes, hw_panel_info_,
+ &display_comp_ctx_);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ display_attributes_[active_mode_index_] = display_attributes;
+
+ return error;
}
DisplayError DisplayVirtual::SetActiveConfig(uint32_t index) {
@@ -152,6 +183,17 @@
return DisplayBase::SetDisplayMode(mode);
}
+DisplayError DisplayVirtual::IsScalingValid(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90) {
+ SCOPE_LOCK(locker_);
+ return DisplayBase::IsScalingValid(crop, dst, rotate90);
+}
+
+DisplayError DisplayVirtual::SetRefreshRate(uint32_t refresh_rate) {
+ SCOPE_LOCK(locker_);
+ return kErrorNotSupported;
+}
+
void DisplayVirtual::AppendDump(char *buffer, uint32_t length) {
SCOPE_LOCK(locker_);
DisplayBase::AppendDump(buffer, length);
diff --git a/displayengine/libs/core/display_virtual.h b/displayengine/libs/core/display_virtual.h
index f868612..6350e26 100644
--- a/displayengine/libs/core/display_virtual.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -56,6 +56,9 @@
virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual DisplayError SetDisplayMode(uint32_t mode);
+ virtual DisplayError IsScalingValid(const LayerRect &crop, const LayerRect &dst, bool rotate90);
+ virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
+ virtual bool IsUnderscanSupported();
virtual void AppendDump(char *buffer, uint32_t length);
private:
diff --git a/displayengine/libs/core/fb/hw_device.cpp b/displayengine/libs/core/fb/hw_device.cpp
index d96820f..809e817 100644
--- a/displayengine/libs/core/fb/hw_device.cpp
+++ b/displayengine/libs/core/fb/hw_device.cpp
@@ -194,7 +194,6 @@
DTRACE_SCOPED();
DisplayError error = kErrorNone;
- ResetDisplayParams();
HWLayersInfo &hw_layer_info = hw_layers->info;
LayerStack *stack = hw_layer_info.stack;
@@ -206,6 +205,12 @@
mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
uint32_t &mdp_layer_count = mdp_commit.input_layer_cnt;
+ DLOGI("left_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.left_roi.x, mdp_commit.left_roi.y,
+ mdp_commit.left_roi.w, mdp_commit.left_roi.h);
+ DLOGI("right_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.right_roi.x,
+ mdp_commit.right_roi.y, mdp_commit.right_roi.w,
+ mdp_commit.right_roi.h);
+
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
Layer &layer = stack->layers[layer_index];
diff --git a/displayengine/libs/core/fb/hw_device.h b/displayengine/libs/core/fb/hw_device.h
index 18c6652..e25709e 100644
--- a/displayengine/libs/core/fb/hw_device.h
+++ b/displayengine/libs/core/fb/hw_device.h
@@ -29,7 +29,6 @@
#include <stdio.h>
#include <stdlib.h>
#include <linux/msm_mdp_ext.h>
-#include <video/msm_hdmi_modes.h>
#include <linux/mdss_rotator.h>
#include <poll.h>
#include <pthread.h>
diff --git a/displayengine/libs/core/fb/hw_hdmi.cpp b/displayengine/libs/core/fb/hw_hdmi.cpp
index d258df3..f8279b2 100644
--- a/displayengine/libs/core/fb/hw_hdmi.cpp
+++ b/displayengine/libs/core/fb/hw_hdmi.cpp
@@ -105,7 +105,7 @@
}
HWHDMI::HWHDMI(BufferSyncHandler *buffer_sync_handler, HWInfoInterface *hw_info_intf)
- : HWDevice(buffer_sync_handler) {
+ : HWDevice(buffer_sync_handler), hw_scan_info_() {
HWDevice::device_type_ = kDeviceHDMI;
HWDevice::device_name_ = "HDMI Display Device";
HWDevice::hw_info_intf_ = hw_info_intf;
@@ -129,6 +129,7 @@
MSM_HDMI_MODES_INIT_TIMINGS(supported_video_modes_);
MSM_HDMI_MODES_SET_SUPP_TIMINGS(supported_video_modes_, MSM_HDMI_MODES_ALL);
+ ReadScanInfo();
return kErrorNone;
CleanupOnError:
@@ -227,7 +228,7 @@
display_attributes->h_total = timing_mode->active_h + h_blanking;
display_attributes->x_dpi = 0;
display_attributes->y_dpi = 0;
- display_attributes->fps = FLOAT(timing_mode->refresh_rate) / 1000.0f;
+ display_attributes->fps = timing_mode->refresh_rate / 1000;
display_attributes->vsync_period_ns = UINT32(1000000000L / display_attributes->fps);
display_attributes->split_left = display_attributes->x_pixels;
if (display_attributes->x_pixels > hw_resource_.max_mixer_width) {
@@ -325,6 +326,7 @@
}
DisplayError HWHDMI::Validate(HWLayers *hw_layers) {
+ HWDevice::ResetDisplayParams();
return HWDevice::Validate(hw_layers);
}
@@ -340,5 +342,80 @@
return HWDevice::GetHWPanelInfo(panel_info);
}
+DisplayError HWHDMI::GetHWScanInfo(HWScanInfo *scan_info) {
+ if (!scan_info) {
+ return kErrorParameters;
+ }
+ *scan_info = hw_scan_info_;
+ return kErrorNone;
+}
+
+DisplayError HWHDMI::GetVideoFormat(uint32_t config_index, uint32_t *video_format) {
+ *video_format = hdmi_modes_[config_index];
+
+ return kErrorNone;
+}
+
+DisplayError HWHDMI::GetMaxCEAFormat(uint32_t *max_cea_format) {
+ *max_cea_format = HDMI_VFRMT_END;
+
+ return kErrorNone;
+}
+
+HWScanSupport HWHDMI::MapHWScanSupport(uint32_t value) {
+ switch (value) {
+ // TODO(user): Read the scan type from driver defined values instead of hardcoding
+ case 0:
+ return kScanNotSupported;
+ case 1:
+ return kScanAlwaysOverscanned;
+ case 2:
+ return kScanAlwaysUnderscanned;
+ case 3:
+ return kScanBoth;
+ default:
+ return kScanNotSupported;
+ break;
+ }
+}
+
+void HWHDMI::ReadScanInfo() {
+ int scan_info_file = -1;
+ ssize_t len = -1;
+ char data[PAGE_SIZE] = {'\0'};
+
+ snprintf(data, sizeof(data), "%s%d/scan_info", fb_path_, fb_node_index_);
+ scan_info_file = open_(data, O_RDONLY);
+ if (scan_info_file < 0) {
+ DLOGW("File '%s' not found.", data);
+ return;
+ }
+
+ memset(&data[0], 0, sizeof(data));
+ len = read(scan_info_file, data, sizeof(data) - 1);
+ if (len <= 0) {
+ close_(scan_info_file);
+ DLOGW("File %s%d/scan_info is empty.", fb_path_, fb_node_index_);
+ return;
+ }
+ data[len] = '\0';
+ close_(scan_info_file);
+
+ const uint32_t scan_info_max_count = 3;
+ uint32_t scan_info_count = 0;
+ char *tokens[scan_info_max_count] = { NULL };
+ ParseLine(data, tokens, scan_info_max_count, &scan_info_count);
+ if (scan_info_count != scan_info_max_count) {
+ DLOGW("Failed to parse scan info string %s", data);
+ return;
+ }
+
+ hw_scan_info_.pt_scan_support = MapHWScanSupport(atoi(tokens[0]));
+ hw_scan_info_.it_scan_support = MapHWScanSupport(atoi(tokens[1]));
+ hw_scan_info_.cea_scan_support = MapHWScanSupport(atoi(tokens[2]));
+ DLOGI("PT %d IT %d CEA %d", hw_scan_info_.pt_scan_support, hw_scan_info_.it_scan_support,
+ hw_scan_info_.cea_scan_support);
+}
+
} // namespace sde
diff --git a/displayengine/libs/core/fb/hw_hdmi.h b/displayengine/libs/core/fb/hw_hdmi.h
index 322e664..adfa1e2 100644
--- a/displayengine/libs/core/fb/hw_hdmi.h
+++ b/displayengine/libs/core/fb/hw_hdmi.h
@@ -25,6 +25,7 @@
#ifndef __HW_HDMI_H__
#define __HW_HDMI_H__
+#include <video/msm_hdmi_modes.h>
#include "hw_device.h"
#include "hw_hdmi_interface.h"
@@ -41,6 +42,9 @@
virtual DisplayError GetDisplayAttributes(HWDisplayAttributes *display_attributes,
uint32_t index);
virtual DisplayError GetHWPanelInfo(HWPanelInfo *panel_info);
+ virtual DisplayError GetHWScanInfo(HWScanInfo *scan_info);
+ virtual DisplayError GetVideoFormat(uint32_t config_index, uint32_t *video_format);
+ virtual DisplayError GetMaxCEAFormat(uint32_t *max_cea_format);
virtual DisplayError SetDisplayAttributes(uint32_t index);
virtual DisplayError GetConfigIndex(uint32_t mode, uint32_t *index);
virtual DisplayError PowerOn();
@@ -54,11 +58,14 @@
private:
int GetHDMIModeCount();
+ void ReadScanInfo();
+ HWScanSupport MapHWScanSupport(uint32_t value);
uint32_t hdmi_mode_count_;
uint32_t hdmi_modes_[256];
// Holds the hdmi timing information. Ex: resolution, fps etc.,
msm_hdmi_mode_timing_info *supported_video_modes_;
+ HWScanInfo hw_scan_info_;
};
} // namespace sde
diff --git a/displayengine/libs/core/fb/hw_primary.cpp b/displayengine/libs/core/fb/hw_primary.cpp
index 87de5d4..1fa4b4e 100644
--- a/displayengine/libs/core/fb/hw_primary.cpp
+++ b/displayengine/libs/core/fb/hw_primary.cpp
@@ -65,7 +65,7 @@
HWPrimary::HWPrimary(BufferSyncHandler *buffer_sync_handler, HWInfoInterface *hw_info_intf)
: HWDevice(buffer_sync_handler), event_thread_name_("SDE_EventThread"), fake_vsync_(false),
- exit_threads_(false) {
+ exit_threads_(false), config_changed_(true) {
HWDevice::device_type_ = kDevicePrimary;
HWDevice::device_name_ = "Primary Display Device";
HWDevice::hw_info_intf_ = hw_info_intf;
@@ -163,6 +163,21 @@
DisplayError HWPrimary::GetDisplayAttributes(HWDisplayAttributes *display_attributes,
uint32_t index) {
+ if (!display_attributes) {
+ return kErrorParameters;
+ }
+
+ if (config_changed_) {
+ PopulateDisplayAttributes();
+ config_changed_ = false;
+ }
+
+ *display_attributes = display_attributes_;
+
+ return kErrorNone;
+}
+
+DisplayError HWPrimary::PopulateDisplayAttributes() {
DTRACE_SCOPED();
// Variable screen info
@@ -187,25 +202,26 @@
var_screeninfo.height = INT(((FLOAT(var_screeninfo.yres) * 25.4f)/160.0f) + 0.5f);
}
- display_attributes->x_pixels = var_screeninfo.xres;
- display_attributes->y_pixels = var_screeninfo.yres;
- display_attributes->v_total = var_screeninfo.yres + var_screeninfo.lower_margin +
+ display_attributes_.x_pixels = var_screeninfo.xres;
+ display_attributes_.y_pixels = var_screeninfo.yres;
+ display_attributes_.v_total = var_screeninfo.yres + var_screeninfo.lower_margin +
var_screeninfo.upper_margin + var_screeninfo.vsync_len;
uint32_t h_blanking = var_screeninfo.right_margin + var_screeninfo.left_margin +
var_screeninfo.hsync_len;
- display_attributes->h_total = var_screeninfo.xres + h_blanking;
- display_attributes->x_dpi =
+ display_attributes_.h_total = var_screeninfo.xres + var_screeninfo.right_margin +
+ var_screeninfo.left_margin + var_screeninfo.hsync_len;
+ display_attributes_.x_dpi =
(FLOAT(var_screeninfo.xres) * 25.4f) / FLOAT(var_screeninfo.width);
- display_attributes->y_dpi =
+ display_attributes_.y_dpi =
(FLOAT(var_screeninfo.yres) * 25.4f) / FLOAT(var_screeninfo.height);
- display_attributes->fps = FLOAT(meta_data.data.panel_frame_rate);
- display_attributes->vsync_period_ns = UINT32(1000000000L / display_attributes->fps);
- display_attributes->is_device_split = (hw_panel_info_.split_info.left_split ||
+ display_attributes_.fps = meta_data.data.panel_frame_rate;
+ display_attributes_.vsync_period_ns = UINT32(1000000000L / display_attributes_.fps);
+ display_attributes_.is_device_split = (hw_panel_info_.split_info.left_split ||
(var_screeninfo.xres > hw_resource_.max_mixer_width)) ? true : false;
- display_attributes->split_left = hw_panel_info_.split_info.left_split ?
- hw_panel_info_.split_info.left_split : display_attributes->x_pixels / 2;
- display_attributes->always_src_split = hw_panel_info_.split_info.always_src_split;
- display_attributes->h_total += display_attributes->is_device_split ? h_blanking : 0;
+ display_attributes_.split_left = hw_panel_info_.split_info.left_split ?
+ hw_panel_info_.split_info.left_split : display_attributes_.x_pixels / 2;
+ display_attributes_.always_src_split = hw_panel_info_.split_info.always_src_split;
+ display_attributes_.h_total += display_attributes_.is_device_split ? h_blanking : 0;
return kErrorNone;
}
@@ -214,6 +230,35 @@
return HWDevice::SetDisplayAttributes(index);
}
+DisplayError HWPrimary::SetRefreshRate(uint32_t refresh_rate) {
+ char node_path[kMaxStringLength] = {0};
+
+ DLOGI("Setting refresh rate to = %d fps", refresh_rate);
+
+ snprintf(node_path, sizeof(node_path), "%s%d/dynamic_fps", fb_path_, fb_node_index_);
+
+ int fd = open_(node_path, O_WRONLY);
+ if (fd < 0) {
+ DLOGE("Failed to open %s with error %s", node_path, strerror(errno));
+ return kErrorFileDescriptor;
+ }
+
+ char refresh_rate_string[kMaxStringLength];
+ snprintf(refresh_rate_string, sizeof(refresh_rate_string), "%d", refresh_rate);
+ ssize_t len = pwrite_(fd, refresh_rate_string, strlen(refresh_rate_string), 0);
+ if (len < 0) {
+ DLOGE("Failed to write %d with error %s", refresh_rate, strerror(errno));
+ close_(fd);
+ return kErrorUndefined;
+ }
+ close_(fd);
+
+ config_changed_ = true;
+ synchronous_commit_ = true;
+
+ return kErrorNone;
+}
+
DisplayError HWPrimary::GetConfigIndex(uint32_t mode, uint32_t *index) {
return HWDevice::GetConfigIndex(mode, index);
}
@@ -254,6 +299,27 @@
}
DisplayError HWPrimary::Validate(HWLayers *hw_layers) {
+ HWDevice::ResetDisplayParams();
+
+ mdp_layer_commit_v1 &mdp_commit = mdp_disp_commit_.commit_v1;
+
+ LayerRect left_roi = hw_layers->info.left_partial_update;
+ LayerRect right_roi = hw_layers->info.right_partial_update;
+ mdp_commit.left_roi.x = INT(left_roi.left);
+ mdp_commit.left_roi.y = INT(left_roi.top);
+ mdp_commit.left_roi.w = INT(left_roi.right - left_roi.left);
+ mdp_commit.left_roi.h = INT(left_roi.bottom - left_roi.top);
+
+ // SDE treats ROI as one full coordinate system.
+ // In case source split is disabled, However, Driver assumes Mixer to operate in
+ // different co-ordinate system.
+ if (!hw_resource_.is_src_split) {
+ mdp_commit.right_roi.x = INT(right_roi.left) - hw_panel_info_.split_info.left_split;
+ mdp_commit.right_roi.y = INT(right_roi.top);
+ mdp_commit.right_roi.w = INT(right_roi.right - right_roi.left);
+ mdp_commit.right_roi.h = INT(right_roi.bottom - right_roi.top);
+ }
+
return HWDevice::Validate(hw_layers);
}
@@ -357,7 +423,7 @@
thermal_level = strtoull(data + strlen("thermal_level="), NULL, 0);
}
- DLOGI("Received thermal notification with thermal level = %d",thermal_level);
+ DLOGI("Received thermal notification with thermal level = %d", thermal_level);
event_handler_->ThermalEvent(thermal_level);
}
diff --git a/displayengine/libs/core/fb/hw_primary.h b/displayengine/libs/core/fb/hw_primary.h
index c41f387..fdf27b3 100644
--- a/displayengine/libs/core/fb/hw_primary.h
+++ b/displayengine/libs/core/fb/hw_primary.h
@@ -54,6 +54,7 @@
virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual DisplayError SetVSyncState(bool enable);
virtual DisplayError SetDisplayMode(const HWDisplayMode hw_display_mode);
+ virtual DisplayError SetRefreshRate(uint32_t refresh_rate);
private:
// Panel modes for the MSMFB_LPM_ENABLE ioctl
@@ -70,12 +71,15 @@
void HandleBlank(char *data);
void HandleIdleTimeout(char *data);
void HandleThermal(char *data);
+ DisplayError PopulateDisplayAttributes();
pollfd poll_fds_[kNumDisplayEvents];
pthread_t event_thread_;
const char *event_thread_name_;
bool fake_vsync_;
bool exit_threads_;
+ HWDisplayAttributes display_attributes_;
+ bool config_changed_;
};
} // namespace sde
diff --git a/displayengine/libs/core/fb/hw_rotator.cpp b/displayengine/libs/core/fb/hw_rotator.cpp
index c698445..99b6a2e 100644
--- a/displayengine/libs/core/fb/hw_rotator.cpp
+++ b/displayengine/libs/core/fb/hw_rotator.cpp
@@ -264,7 +264,7 @@
}
}
- void HWRotator::SetMDPFlags(const Layer &layer, uint32_t *mdp_flags) {
+void HWRotator::SetMDPFlags(const Layer &layer, uint32_t *mdp_flags) {
LayerTransform transform = layer.transform;
bool rot90 = (transform.rotation == 90.0f);
diff --git a/displayengine/libs/core/fb/hw_virtual.cpp b/displayengine/libs/core/fb/hw_virtual.cpp
index 374cc45..f108cfa 100644
--- a/displayengine/libs/core/fb/hw_virtual.cpp
+++ b/displayengine/libs/core/fb/hw_virtual.cpp
@@ -119,6 +119,7 @@
}
DisplayError HWVirtual::Validate(HWLayers *hw_layers) {
+ HWDevice::ResetDisplayParams();
return HWDevice::Validate(hw_layers);
}
diff --git a/displayengine/libs/core/hw_hdmi_interface.h b/displayengine/libs/core/hw_hdmi_interface.h
index 36ca991..276fefd 100644
--- a/displayengine/libs/core/hw_hdmi_interface.h
+++ b/displayengine/libs/core/hw_hdmi_interface.h
@@ -36,6 +36,9 @@
static DisplayError Create(HWHDMIInterface **intf, HWInfoInterface *hw_info_intf,
BufferSyncHandler *buffer_sync_handler);
static DisplayError Destroy(HWHDMIInterface *intf);
+ virtual DisplayError GetHWScanInfo(HWScanInfo *scan_info) = 0;
+ virtual DisplayError GetVideoFormat(uint32_t config_index, uint32_t *video_format) = 0;
+ virtual DisplayError GetMaxCEAFormat(uint32_t *max_cea_format) = 0;
protected:
virtual ~HWHDMIInterface() { }
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index 5610ccd..0c8288f 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -174,6 +174,19 @@
HWDisplayAttributes() : is_device_split(false), split_left(0), always_src_split(false) { }
void Reset() { *this = HWDisplayAttributes(); }
+
+ bool operator !=(const HWDisplayAttributes &attributes) {
+ return ((is_device_split != attributes.is_device_split) ||
+ (split_left != attributes.split_left) ||
+ (always_src_split != attributes.always_src_split) ||
+ (x_pixels != attributes.x_pixels) || (y_pixels != attributes.y_pixels) ||
+ (x_dpi != attributes.x_dpi) || (y_dpi != attributes.y_dpi) || (fps != attributes.fps) ||
+ (vsync_period_ns != attributes.vsync_period_ns) || (v_total != attributes.v_total));
+ }
+
+ bool operator ==(const HWDisplayAttributes &attributes) {
+ return !(operator !=(attributes));
+ }
};
// HWEventHandler - Implemented in DisplayBase and HWInterface implementation
diff --git a/displayengine/libs/core/hw_primary_interface.h b/displayengine/libs/core/hw_primary_interface.h
index d195348..edc1795 100644
--- a/displayengine/libs/core/hw_primary_interface.h
+++ b/displayengine/libs/core/hw_primary_interface.h
@@ -38,6 +38,7 @@
virtual DisplayError SetVSyncState(bool enable) = 0;
virtual void SetIdleTimeoutMs(uint32_t timeout_ms) = 0;
virtual DisplayError SetDisplayMode(const HWDisplayMode hw_display_mode) = 0;
+ virtual DisplayError SetRefreshRate(uint32_t refresh_rate) = 0;
protected:
virtual ~HWPrimaryInterface() { }
diff --git a/displayengine/libs/core/res_config.cpp b/displayengine/libs/core/res_config.cpp
index c5a8a06..a8f9017 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -142,31 +142,39 @@
DisplayError ResManager::DisplaySplitConfig(DisplayResourceContext *display_resource_ctx,
const LayerTransform &transform,
const LayerRect &src_rect, const LayerRect &dst_rect,
- HWLayerConfig *layer_config, uint32_t align_x) {
+ const HWLayers &hw_layers, HWLayerConfig *layer_config,
+ uint32_t align_x) {
LayerRect scissor_dst_left, scissor_dst_right;
HWDisplayAttributes &display_attributes = display_resource_ctx->display_attributes;
// for display split case
HWPipeInfo *left_pipe = &layer_config->left_pipe;
HWPipeInfo *right_pipe = &layer_config->right_pipe;
- LayerRect scissor, dst_left, crop_left, crop_right, dst_right;
- scissor.right = FLOAT(display_attributes.split_left);
- scissor.bottom = FLOAT(display_attributes.y_pixels);
+ LayerRect scissor_left, scissor_right, dst_left, crop_left, crop_right, dst_right;
+
+ scissor_left.right = FLOAT(display_attributes.split_left);
+ scissor_left.bottom = FLOAT(display_attributes.y_pixels);
+
+ scissor_right.left = FLOAT(display_attributes.split_left);
+ scissor_right.top = 0.0f;
+ scissor_right.right = FLOAT(display_attributes.x_pixels);
+ scissor_right.bottom = FLOAT(display_attributes.y_pixels);
+
+ if (IsValid(hw_layers.info.left_partial_update) ||
+ IsValid(hw_layers.info.right_partial_update)) {
+ scissor_left = hw_layers.info.left_partial_update;
+ scissor_right = hw_layers.info.right_partial_update;
+ }
crop_left = src_rect;
dst_left = dst_rect;
crop_right = crop_left;
dst_right = dst_left;
- bool crop_left_valid = CalculateCropRects(scissor, transform, &crop_left, &dst_left);
-
- scissor.left = FLOAT(display_attributes.split_left);
- scissor.top = 0.0f;
- scissor.right = FLOAT(display_attributes.x_pixels);
- scissor.bottom = FLOAT(display_attributes.y_pixels);
+ bool crop_left_valid = CalculateCropRects(scissor_left, transform, &crop_left, &dst_left);
bool crop_right_valid = false;
- if (IsValid(scissor)) {
- crop_right_valid = CalculateCropRects(scissor, transform, &crop_right, &dst_right);
+ if (IsValid(scissor_right)) {
+ crop_right_valid = CalculateCropRects(scissor_right, transform, &crop_right, &dst_right);
}
if (crop_left_valid && (crop_left.right - crop_left.left) > hw_res_info_.max_pipe_width) {
@@ -248,6 +256,10 @@
scissor.right = FLOAT(display_attributes.x_pixels);
scissor.bottom = FLOAT(display_attributes.y_pixels);
+ if (IsValid(hw_layers->info.left_partial_update)) {
+ scissor = hw_layers->info.left_partial_update;
+ }
+
struct HWLayerConfig *layer_config = &hw_layers->config[i];
HWPipeInfo &left_pipe = layer_config->left_pipe;
HWPipeInfo &right_pipe = layer_config->right_pipe;
@@ -295,19 +307,21 @@
transform = LayerTransform();
}
+ // TODO(user): need to revisit this logic
if (hw_res_info_.is_src_split) {
- error = SrcSplitConfig(display_resource_ctx, transform, src_rect,
- dst_rect, layer_config, align_x);
+ error = SrcSplitConfig(display_resource_ctx, transform, src_rect, dst_rect, layer_config,
+ align_x);
} else {
- error = DisplaySplitConfig(display_resource_ctx, transform, src_rect,
- dst_rect, layer_config, align_x);
+ error = DisplaySplitConfig(display_resource_ctx, transform, src_rect, dst_rect, *hw_layers,
+ layer_config, align_x);
}
if (error != kErrorNone) {
break;
}
- error = AlignPipeConfig(layer, transform, &left_pipe, &right_pipe, align_x, align_y);
+ error = AlignPipeConfig(layer, transform, *hw_layers, &left_pipe, &right_pipe, align_x,
+ align_y);
if (error != kErrorNone) {
break;
}
@@ -742,8 +756,9 @@
}
DisplayError ResManager::AlignPipeConfig(const Layer &layer, const LayerTransform &transform,
- HWPipeInfo *left_pipe, HWPipeInfo *right_pipe,
- uint32_t align_x, uint32_t align_y) {
+ const HWLayers &hw_layers, HWPipeInfo *left_pipe,
+ HWPipeInfo *right_pipe, uint32_t align_x,
+ uint32_t align_y) {
DisplayError error = kErrorNone;
if (!left_pipe->valid) {
DLOGE_IF(kTagResources, "left_pipe should not be invalid");
@@ -753,7 +768,6 @@
// rectangle of video layer to be even.
// 2. Normalize source and destination rect of a layer to multiple of 1.
// TODO(user) Check buffer format and check if rotate is involved.
-
Normalize(align_x, align_y, &left_pipe->src_roi);
Normalize(1, 1, &left_pipe->dst_roi);
@@ -762,8 +776,10 @@
Normalize(1, 1, &right_pipe->dst_roi);
}
- if (right_pipe->valid) {
- // Make sure the left and right ROI are conjunct
+ // Make sure the left and right ROI are conjunct, then make pipes ROI conjunct.
+ if (right_pipe->valid &&
+ (!IsValid(hw_layers.info.right_partial_update) ||
+ (hw_layers.info.left_partial_update.right == hw_layers.info.right_partial_update.left))) {
if (transform.flip_horizontal) {
left_pipe->src_roi.left = right_pipe->src_roi.right;
} else {
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index 7344c21..b5b8db1 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -197,6 +197,17 @@
return kErrorNone;
}
+void ResManager::ReconfigureDisplay(Handle display_ctx, const HWDisplayAttributes &attributes,
+ const HWPanelInfo &hw_panel_info) {
+ SCOPE_LOCK(locker_);
+
+ DisplayResourceContext *display_resource_ctx =
+ reinterpret_cast<DisplayResourceContext *>(display_ctx);
+
+ display_resource_ctx->display_attributes = attributes;
+ display_resource_ctx->hw_panel_info_ = hw_panel_info;
+}
+
DisplayError ResManager::Start(Handle display_ctx) {
locker_.Lock();
@@ -492,7 +503,7 @@
float decimation = powf(2.0f, pipe->vertical_decimation);
src_h /= decimation;
- float bw = src_w * src_h * bpp * display_attributes.fps;
+ float bw = src_w * src_h * bpp * FLOAT(display_attributes.fps);
// Consider panel dimension
// (v_total / v_active) * (v_active / dst_h)
@@ -522,7 +533,7 @@
float ResManager::GetClockForPipe(DisplayResourceContext *display_ctx, HWPipeInfo *pipe) {
HWDisplayAttributes &display_attributes = display_ctx->display_attributes;
float v_total = FLOAT(display_attributes.v_total);
- float fps = display_attributes.fps;
+ float fps = FLOAT(display_attributes.fps);
float src_h = pipe->src_roi.bottom - pipe->src_roi.top;
float dst_h = pipe->dst_roi.bottom - pipe->dst_roi.top;
@@ -619,6 +630,8 @@
case kFormatXRGB8888:
case kFormatRGBX8888:
case kFormatBGRX8888:
+ case kFormatRGBA8888Ubwc:
+ case kFormatRGBX8888Ubwc:
return 4.0f;
case kFormatRGB888:
case kFormatBGR888:
@@ -626,6 +639,7 @@
case kFormatRGB565:
case kFormatRGBA5551:
case kFormatRGBA4444:
+ case kFormatRGB565Ubwc:
case kFormatYCbCr422H2V1Packed:
case kFormatYCrCb422H2V1SemiPlanar:
case kFormatYCrCb422H1V2SemiPlanar:
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index 32eb6ea..1f8f48e 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -43,6 +43,8 @@
DisplayError RegisterDisplay(DisplayType type, const HWDisplayAttributes &attributes,
const HWPanelInfo &hw_panel_info, Handle *display_ctx);
DisplayError UnregisterDisplay(Handle display_ctx);
+ void ReconfigureDisplay(Handle display_ctx, const HWDisplayAttributes &attributes,
+ const HWPanelInfo &hw_panel_info);
DisplayError Start(Handle display_ctx);
DisplayError Stop(Handle display_ctx);
DisplayError Acquire(Handle display_ctx, HWLayers *hw_layers);
@@ -162,9 +164,12 @@
DisplayError Config(DisplayResourceContext *display_resource_ctx, HWLayers *hw_layers,
uint32_t *rotate_count);
DisplayError DisplaySplitConfig(DisplayResourceContext *display_resource_ctx,
- const LayerTransform &transform, const LayerRect &src_rect,
- const LayerRect &dst_rect, HWLayerConfig *layer_config,
+ const LayerTransform &transform,
+ const LayerRect &src_rect, const LayerRect &dst_rect,
+ const HWLayers &hw_layers, HWLayerConfig *layer_config,
uint32_t align_x);
+ DisplayError ValidateScaling(const Layer &layer, const LayerRect &crop,
+ const LayerRect &dst, float *rot_scale);
DisplayError SrcSplitConfig(DisplayResourceContext *display_resource_ctx,
const LayerTransform &transform, const LayerRect &src_rect,
const LayerRect &dst_rect, HWLayerConfig *layer_config,
@@ -208,8 +213,8 @@
const bool &rot90, const bool &downscale,
LayerBufferFormat *output_format);
DisplayError AlignPipeConfig(const Layer &layer, const LayerTransform &transform,
- HWPipeInfo *left_pipe, HWPipeInfo *right_pipe,
- uint32_t align_x, uint32_t align_y);
+ const HWLayers &hw_layers, HWPipeInfo *left_pipe,
+ HWPipeInfo *right_pipe, uint32_t align_x, uint32_t align_y);
void ResourceStateLog(void);
DisplayError CalculateDecimation(float downscale, uint8_t *decimation);
diff --git a/displayengine/libs/core/scalar_helper.h b/displayengine/libs/core/scalar_helper.h
old mode 100755
new mode 100644
diff --git a/displayengine/libs/core/strategy_default.cpp b/displayengine/libs/core/strategy_default.cpp
index 48fc79d..4aab34d 100644
--- a/displayengine/libs/core/strategy_default.cpp
+++ b/displayengine/libs/core/strategy_default.cpp
@@ -31,14 +31,17 @@
namespace sde {
-StrategyDefault::StrategyDefault() : hw_layers_info_(NULL) {
+StrategyDefault::StrategyDefault(DisplayType type, const HWResourceInfo &hw_resource_info,
+ const HWPanelInfo &hw_panel_info) : type_(type),
+ hw_resource_info_(hw_resource_info),
+ hw_panel_info_(hw_panel_info), hw_layers_info_(NULL) {
}
DisplayError StrategyDefault::CreateStrategyInterface(uint16_t version, DisplayType type,
- const HWResourceInfo *hw_resource_info,
- const HWPanelInfo *hw_panel_info,
+ const HWResourceInfo &hw_resource_info,
+ const HWPanelInfo &hw_panel_info,
StrategyInterface **interface) {
- StrategyDefault *strategy_default = new StrategyDefault();
+ StrategyDefault *strategy_default = new StrategyDefault(type, hw_resource_info, hw_panel_info);
if (!strategy_default) {
return kErrorMemory;
@@ -61,6 +64,18 @@
return kErrorNone;
}
+bool StrategyDefault::IsDisplaySplit(uint32_t fb_x_res) {
+ if (fb_x_res > hw_resource_info_.max_mixer_width) {
+ return true;
+ }
+
+ if ((type_ == kPrimary) && hw_panel_info_.split_info.right_split) {
+ return true;
+ }
+
+ return false;
+}
+
DisplayError StrategyDefault::Start(HWLayersInfo *hw_layers_info, uint32_t *max_attempts) {
if (!hw_layers_info) {
return kErrorParameters;
@@ -69,6 +84,29 @@
hw_layers_info_ = hw_layers_info;
*max_attempts = 1;
+ const LayerStack *layer_stack = hw_layers_info_->stack;
+ for (uint32_t i = 0; i < layer_stack->layer_count; i++) {
+ LayerComposition &composition = layer_stack->layers[i].composition;
+ if (composition == kCompositionGPUTarget) {
+ fb_layer_index_ = i;
+ break;
+ }
+ }
+
+ const LayerRect &src_rect = hw_layers_info_->stack->layers[fb_layer_index_].src_rect;
+ // TODO(user): read panels x_pixels and y_pixels instead of fb_x_res and fb_y_res
+ const float fb_x_res = src_rect.right - src_rect.left;
+ const float fb_y_res = src_rect.bottom - src_rect.top;
+
+ if (IsDisplaySplit(INT(fb_x_res))) {
+ float left_split = FLOAT(hw_panel_info_.split_info.left_split);
+ hw_layers_info->left_partial_update = (LayerRect) {0.0, 0.0, left_split, fb_y_res};
+ hw_layers_info->right_partial_update = (LayerRect) {left_split, 0.0, fb_x_res, fb_y_res};
+ } else {
+ hw_layers_info->left_partial_update = (LayerRect) {0.0, 0.0, fb_x_res, fb_y_res};
+ hw_layers_info->right_partial_update = (LayerRect) {0.0, 0.0, 0.0, 0.0};
+ }
+
return kErrorNone;
}
diff --git a/displayengine/libs/core/strategy_default.h b/displayengine/libs/core/strategy_default.h
index 7b6f594..37d5f9d 100644
--- a/displayengine/libs/core/strategy_default.h
+++ b/displayengine/libs/core/strategy_default.h
@@ -32,11 +32,11 @@
class StrategyDefault : public StrategyInterface {
public:
- StrategyDefault();
-
+ StrategyDefault(DisplayType type, const HWResourceInfo &hw_resource_info,
+ const HWPanelInfo &hw_panel_info);
static DisplayError CreateStrategyInterface(uint16_t version, DisplayType type,
- const HWResourceInfo *hw_resource_info,
- const HWPanelInfo *hw_panel_info,
+ const HWResourceInfo &hw_resource_info,
+ const HWPanelInfo &hw_panel_info,
StrategyInterface **interface);
static DisplayError DestroyStrategyInterface(StrategyInterface *interface);
@@ -45,7 +45,12 @@
virtual DisplayError Stop();
private:
+ bool IsDisplaySplit(uint32_t fb_x_res);
+ DisplayType type_;
+ HWResourceInfo hw_resource_info_;
+ HWPanelInfo hw_panel_info_;
HWLayersInfo *hw_layers_info_;
+ int fb_layer_index_;
};
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display.cpp b/displayengine/libs/hwc/hwc_display.cpp
index 724b720..7794731 100644
--- a/displayengine/libs/hwc/hwc_display.cpp
+++ b/displayengine/libs/hwc/hwc_display.cpp
@@ -46,7 +46,8 @@
int id)
: core_intf_(core_intf), hwc_procs_(hwc_procs), type_(type), id_(id), display_intf_(NULL),
flush_(false), output_buffer_(NULL), dump_frame_count_(0), dump_frame_index_(0),
- dump_input_layers_(false), swap_interval_zero_(false) {
+ dump_input_layers_(false), swap_interval_zero_(false), framebuffer_config_(NULL),
+ display_paused_(false), use_metadata_refresh_rate_(false),metadata_refresh_rate_(0) {
}
int HWCDisplay::Init() {
@@ -64,6 +65,13 @@
}
}
+ framebuffer_config_ = new DisplayConfigVariableInfo();
+ if (!framebuffer_config_) {
+ DLOGV("Failed to allocate memory for custom framebuffer config.");
+ core_intf_->DestroyDisplay(display_intf_);
+ return -EINVAL;
+ }
+
return 0;
}
@@ -79,6 +87,8 @@
layer_stack_memory_.raw = NULL;
}
+ delete framebuffer_config_;
+
return 0;
}
@@ -150,10 +160,15 @@
DisplayError error = kErrorNone;
DisplayConfigVariableInfo variable_config;
- error = display_intf_->GetConfig(config, &variable_config);
- if (error != kErrorNone) {
- DLOGE("GetConfig variable info failed. Error = %d", error);
- return -EINVAL;
+ uint32_t active_config = UINT32(GetActiveConfig());
+ if (IsFrameBufferScaled() && config == active_config) {
+ variable_config = *framebuffer_config_;
+ } else {
+ error = display_intf_->GetConfig(config, &variable_config);
+ if (error != kErrorNone) {
+ DLOGE("GetConfig variable info failed. Error = %d", error);
+ return -EINVAL;
+ }
}
for (int i = 0; attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE; i++) {
@@ -327,6 +342,12 @@
return 0;
}
+ DisplayConfigVariableInfo active_config;
+ uint32_t active_config_index = 0;
+ display_intf_->GetActiveConfig(&active_config_index);
+
+ display_intf_->GetConfig(active_config_index, &active_config);
+
// Configure each layer
for (size_t i = 0; i < num_hw_layers; i++) {
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
@@ -352,11 +373,10 @@
layer_buffer->flags.secure = true;
}
- // TODO(user) : Initialize it to display refresh rate
- layer.frame_rate = 60;
+ layer.frame_rate = UINT32(active_config.fps);
MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata);
if (meta_data && meta_data->operation & UPDATE_REFRESH_RATE) {
- layer.frame_rate = meta_data->refreshrate;
+ layer.frame_rate = RoundToStandardFPS(meta_data->refreshrate);
}
if (meta_data && meta_data->operation == PP_PARAM_INTERLACED && meta_data->interlaced) {
@@ -368,7 +388,11 @@
}
}
- SetRect(hwc_layer.displayFrame, &layer.dst_rect);
+ hwc_rect_t scaled_display_frame = hwc_layer.displayFrame;
+ ScaleDisplayFrame(&scaled_display_frame);
+ ApplyScanAdjustment(&scaled_display_frame);
+
+ SetRect(scaled_display_frame, &layer.dst_rect);
SetRect(hwc_layer.sourceCropf, &layer.src_rect);
for (size_t j = 0; j < hwc_layer.visibleRegionScreen.numRects; j++) {
SetRect(hwc_layer.visibleRegionScreen.rects[j], &layer.visible_regions.rect[j]);
@@ -412,6 +436,8 @@
bool needs_fb_refresh = NeedsFrameBufferRefresh(content_list);
+ metadata_refresh_rate_ = 0;
+
for (size_t i = 0; i < num_hw_layers; i++) {
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
Layer &layer = layer_stack_.layers[i];
@@ -419,6 +445,10 @@
if (composition == kCompositionSDE) {
hwc_layer.hints |= HWC_HINT_CLEAR_FB;
+
+ if (use_metadata_refresh_rate_ && layer.frame_rate > metadata_refresh_rate_) {
+ metadata_refresh_rate_ = layer.frame_rate;
+ }
}
// If current layer does not need frame buffer redraw, then mark it as HWC_OVERLAY
@@ -810,5 +840,169 @@
}
}
+int HWCDisplay::SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels) {
+ if (x_pixels <= 0 || y_pixels <= 0) {
+ DLOGV("Unsupported config: x_pixels=%d, y_pixels=%d", x_pixels, y_pixels);
+ return -EINVAL;
+ }
+
+ if (framebuffer_config_->x_pixels == x_pixels && framebuffer_config_->y_pixels == y_pixels) {
+ return 0;
+ }
+
+ DisplayConfigVariableInfo active_config;
+ int active_config_index = GetActiveConfig();
+ DisplayError error = display_intf_->GetConfig(active_config_index, &active_config);
+ if (error != kErrorNone) {
+ DLOGV("GetConfig variable info failed. Error = %d", error);
+ return -EINVAL;
+ }
+
+ if (active_config.x_pixels <= 0 || active_config.y_pixels <= 0) {
+ DLOGV("Invalid panel resolution (%dx%d)", active_config.x_pixels, active_config.y_pixels);
+ return -EINVAL;
+ }
+
+ // Create rects to represent the new source and destination crops
+ LayerRect crop = LayerRect(0, 0, FLOAT(x_pixels), FLOAT(y_pixels));
+ LayerRect dst = LayerRect(0, 0, FLOAT(active_config.x_pixels), FLOAT(active_config.y_pixels));
+ // Set rotate90 to false since this is taken care of during regular composition.
+ bool rotate90 = false;
+ error = display_intf_->IsScalingValid(crop, dst, rotate90);
+ if (error != kErrorNone) {
+ DLOGV("Unsupported resolution: (%dx%d)", x_pixels, y_pixels);
+ return -EINVAL;
+ }
+
+ uint32_t panel_width =
+ UINT32((FLOAT(active_config.x_pixels) * 25.4f) / FLOAT(active_config.x_dpi));
+ uint32_t panel_height =
+ UINT32((FLOAT(active_config.y_pixels) * 25.4f) / FLOAT(active_config.y_dpi));
+ framebuffer_config_->x_pixels = x_pixels;
+ framebuffer_config_->y_pixels = y_pixels;
+ framebuffer_config_->vsync_period_ns = active_config.vsync_period_ns;
+ framebuffer_config_->x_dpi =
+ (FLOAT(framebuffer_config_->x_pixels) * 25.4f) / FLOAT(panel_width);
+ framebuffer_config_->y_dpi =
+ (FLOAT(framebuffer_config_->y_pixels) * 25.4f) / FLOAT(panel_height);
+
+ DLOGI("New framebuffer resolution (%dx%d)", framebuffer_config_->x_pixels,
+ framebuffer_config_->y_pixels);
+
+ return 0;
+}
+
+void HWCDisplay::GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
+ *x_pixels = framebuffer_config_->x_pixels;
+ *y_pixels = framebuffer_config_->y_pixels;
+}
+
+void HWCDisplay::ScaleDisplayFrame(hwc_rect_t *display_frame) {
+ if (!IsFrameBufferScaled()) {
+ return;
+ }
+
+ int active_config_index = GetActiveConfig();
+ DisplayConfigVariableInfo active_config;
+ DisplayError error = display_intf_->GetConfig(active_config_index, &active_config);
+ if (error != kErrorNone) {
+ DLOGE("GetConfig variable info failed. Error = %d", error);
+ return;
+ }
+
+ float custom_x_pixels = FLOAT(framebuffer_config_->x_pixels);
+ float custom_y_pixels = FLOAT(framebuffer_config_->y_pixels);
+ float active_x_pixels = FLOAT(active_config.x_pixels);
+ float active_y_pixels = FLOAT(active_config.y_pixels);
+ float x_pixels_ratio = active_x_pixels / custom_x_pixels;
+ float y_pixels_ratio = active_y_pixels / custom_y_pixels;
+ float layer_width = FLOAT(display_frame->right - display_frame->left);
+ float layer_height = FLOAT(display_frame->bottom - display_frame->top);
+
+ display_frame->left = INT(x_pixels_ratio * FLOAT(display_frame->left));
+ display_frame->top = INT(y_pixels_ratio * FLOAT(display_frame->top));
+ display_frame->right = INT(FLOAT(display_frame->left) + layer_width * x_pixels_ratio);
+ display_frame->bottom = INT(FLOAT(display_frame->top) + layer_height * y_pixels_ratio);
+}
+
+bool HWCDisplay::IsFrameBufferScaled() {
+ if (framebuffer_config_->x_pixels == 0 || framebuffer_config_->y_pixels == 0) {
+ return false;
+ }
+ uint32_t panel_x_pixels = 0;
+ uint32_t panel_y_pixels = 0;
+ GetPanelResolution(&panel_x_pixels, &panel_y_pixels);
+ return (framebuffer_config_->x_pixels != panel_x_pixels) ||
+ (framebuffer_config_->y_pixels != panel_y_pixels);
+}
+
+void HWCDisplay::GetPanelResolution(uint32_t *x_pixels, uint32_t *y_pixels) {
+ DisplayConfigVariableInfo active_config;
+ int active_config_index = GetActiveConfig();
+ DisplayError error = display_intf_->GetConfig(active_config_index, &active_config);
+ if (error != kErrorNone) {
+ DLOGE("GetConfig variable info failed. Error = %d", error);
+ return;
+ }
+ *x_pixels = active_config.x_pixels;
+ *y_pixels = active_config.y_pixels;
+}
+
+int HWCDisplay::SetDisplayStatus(uint32_t display_status) {
+ int status = 0;
+
+ switch (display_status) {
+ case kDisplayStatusResume:
+ display_paused_ = false;
+ case kDisplayStatusOnline:
+ status = SetPowerMode(HWC_POWER_MODE_NORMAL);
+ break;
+ case kDisplayStatusPause:
+ display_paused_ = true;
+ case kDisplayStatusOffline:
+ status = SetPowerMode(HWC_POWER_MODE_OFF);
+ break;
+ default:
+ DLOGW("Invalid display status %d", display_status);
+ return -EINVAL;
+ }
+
+ return status;
+}
+
+void HWCDisplay::MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list) {
+ for (size_t i = 0 ; i < (content_list->numHwLayers - 1); i++) {
+ hwc_layer_1_t *layer = &content_list->hwLayers[i];
+ layer->compositionType = HWC_OVERLAY;
+ }
+}
+
+void HWCDisplay::CloseAcquireFences(hwc_display_contents_1_t *content_list) {
+ for (size_t i = 0; i < content_list->numHwLayers; i++) {
+ if (content_list->hwLayers[i].acquireFenceFd >= 0) {
+ close(content_list->hwLayers[i].acquireFenceFd);
+ content_list->hwLayers[i].acquireFenceFd = -1;
+ }
+ }
+}
+
+uint32_t HWCDisplay::RoundToStandardFPS(uint32_t fps) {
+ static const uint32_t standard_fps[4] = {30, 24, 48, 60};
+
+ int count = INT(sizeof(standard_fps) / sizeof(standard_fps[0]));
+ for (int i = 0; i < count; i++) {
+ if (abs(standard_fps[i] - fps) < 2) {
+ // Most likely used for video, the fps can fluctuate
+ // Ex: b/w 29 and 30 for 30 fps clip
+ return standard_fps[i];
+ }
+ }
+
+ return fps;
+}
+
+void HWCDisplay::ApplyScanAdjustment(hwc_rect_t *display_frame) {
+}
+
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display.h b/displayengine/libs/hwc/hwc_display.h
index d14699f..8a68619 100644
--- a/displayengine/libs/hwc/hwc_display.h
+++ b/displayengine/libs/hwc/hwc_display.h
@@ -42,13 +42,24 @@
virtual int GetDisplayAttributes(uint32_t config, const uint32_t *attributes, int32_t *values);
virtual int GetActiveConfig();
virtual int SetActiveConfig(int index);
- virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual int SetActiveConfig(hwc_display_contents_1_t *content_list);
+ virtual void SetIdleTimeoutMs(uint32_t timeout_ms);
virtual void SetFrameDumpConfig(uint32_t count, uint32_t bit_mask_layer_type);
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual uint32_t GetLastPowerMode();
+ virtual int SetFrameBufferResolution(uint32_t x_pixels, uint32_t y_pixels);
+ virtual void GetFrameBufferResolution(uint32_t *x_pixels, uint32_t *y_pixels);
+ virtual void GetPanelResolution(uint32_t *x_pixels, uint32_t *y_pixels);
+ virtual int SetDisplayStatus(uint32_t display_status);
protected:
+ enum DisplayStatus {
+ kDisplayStatusOffline = 0,
+ kDisplayStatusOnline,
+ kDisplayStatusPause,
+ kDisplayStatusResume,
+ };
+
// Maximum number of layers supported by display engine.
static const uint32_t kMaxLayerCount = 32;
@@ -99,6 +110,12 @@
void DumpInputBuffers(hwc_display_contents_1_t *content_list);
const char *GetHALPixelFormatString(int format);
const char *GetDisplayString();
+ void ScaleDisplayFrame(hwc_rect_t *display_frame);
+ bool IsFrameBufferScaled();
+ void MarkLayersForGPUBypass(hwc_display_contents_1_t *content_list);
+ void CloseAcquireFences(hwc_display_contents_1_t *content_list);
+ uint32_t RoundToStandardFPS(uint32_t fps);
+ virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
enum {
INPUT_LAYER_DUMP,
@@ -120,6 +137,10 @@
bool dump_input_layers_;
uint32_t last_power_mode_;
bool swap_interval_zero_;
+ DisplayConfigVariableInfo *framebuffer_config_;
+ bool display_paused_;
+ bool use_metadata_refresh_rate_;
+ uint32_t metadata_refresh_rate_;
};
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display_external.cpp b/displayengine/libs/hwc/hwc_display_external.cpp
index 2758e3a..9e57114 100644
--- a/displayengine/libs/hwc/hwc_display_external.cpp
+++ b/displayengine/libs/hwc/hwc_display_external.cpp
@@ -27,6 +27,7 @@
* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include <cutils/properties.h>
#include <utils/constants.h>
#include "hwc_display_external.h"
@@ -40,6 +41,17 @@
: HWCDisplay(core_intf, hwc_procs, kHDMI, HWC_DISPLAY_EXTERNAL) {
}
+int HWCDisplayExternal::Init() {
+ int status = 0;
+
+ status = HWCDisplay::Init();
+ if (status != 0) {
+ return status;
+ }
+
+ return status;
+}
+
int HWCDisplayExternal::Prepare(hwc_display_contents_1_t *content_list) {
int status = 0;
@@ -91,5 +103,39 @@
return 0;
}
+void HWCDisplayExternal::ApplyScanAdjustment(hwc_rect_t *display_frame) {
+ if (display_intf_->IsUnderscanSupported()) {
+ return;
+ }
+
+ // Read user defined width and height ratio
+ char property[PROPERTY_VALUE_MAX];
+ property_get("persist.sys.actionsafe.width", property, "0");
+ float width_ratio = FLOAT(atoi(property)) / 100.0f;
+ property_get("persist.sys.actionsafe.height", property, "0");
+ float height_ratio = FLOAT(atoi(property)) / 100.0f;
+
+ if (width_ratio == 0.0f || height_ratio == 0.0f) {
+ return;
+ }
+
+ uint32_t panel_width = 0;
+ uint32_t panel_height = 0;
+ GetPanelResolution(&panel_width, &panel_height);
+
+ if (panel_width == 0 || panel_height == 0) {
+ DLOGV("Invalid panel dimensions (%d, %d)", panel_width, panel_height);
+ return;
+ }
+
+ int x_offset = INT((FLOAT(panel_width) * width_ratio) / 2.0f);
+ int y_offset = INT((FLOAT(panel_height) * height_ratio) / 2.0f);
+
+ display_frame->left = display_frame->left + x_offset;
+ display_frame->top = display_frame->top + y_offset;
+ display_frame->right = display_frame->right - x_offset;
+ display_frame->bottom = display_frame->bottom - y_offset;
+}
+
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display_external.h b/displayengine/libs/hwc/hwc_display_external.h
index e268621..6795761 100644
--- a/displayengine/libs/hwc/hwc_display_external.h
+++ b/displayengine/libs/hwc/hwc_display_external.h
@@ -32,9 +32,12 @@
class HWCDisplayExternal : public HWCDisplay {
public:
explicit HWCDisplayExternal(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
+ virtual int Init();
virtual int Prepare(hwc_display_contents_1_t *content_list);
virtual int Commit(hwc_display_contents_1_t *content_list);
virtual int GetDisplayConfigs(uint32_t *configs, size_t *num_configs);
+ private:
+ virtual void ApplyScanAdjustment(hwc_rect_t *display_frame);
};
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display_primary.cpp b/displayengine/libs/hwc/hwc_display_primary.cpp
index d1cd2d2..751162e 100644
--- a/displayengine/libs/hwc/hwc_display_primary.cpp
+++ b/displayengine/libs/hwc/hwc_display_primary.cpp
@@ -53,6 +53,10 @@
return status;
}
+ if (use_metadata_refresh_rate_) {
+ SetRefreshRate(metadata_refresh_rate_);
+ }
+
return 0;
}
@@ -82,5 +86,29 @@
return error;
}
+int HWCDisplayPrimary::SetActiveConfig(uint32_t index) {
+ DisplayError error = kErrorNone;
+
+ if (display_intf_) {
+ error = display_intf_->SetActiveConfig(index);
+ }
+
+ return error;
+}
+
+int HWCDisplayPrimary::SetRefreshRate(uint32_t refresh_rate) {
+ DisplayError error = kErrorNone;
+
+ if (display_intf_) {
+ error = display_intf_->SetRefreshRate(refresh_rate);
+ }
+
+ return error;
+}
+
+void HWCDisplayPrimary::SetMetaDataRefreshRateFlag(bool enable) {
+ use_metadata_refresh_rate_ = enable;
+}
+
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display_primary.h b/displayengine/libs/hwc/hwc_display_primary.h
index 5015fff..cabedc2 100644
--- a/displayengine/libs/hwc/hwc_display_primary.h
+++ b/displayengine/libs/hwc/hwc_display_primary.h
@@ -35,6 +35,9 @@
virtual int Prepare(hwc_display_contents_1_t *content_list);
virtual int Commit(hwc_display_contents_1_t *content_list);
virtual DisplayError SetDisplayMode(uint32_t mode);
+ virtual int SetActiveConfig(uint32_t index);
+ virtual int SetRefreshRate(uint32_t refresh_rate);
+ virtual void SetMetaDataRefreshRateFlag(bool enable);
};
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display_virtual.cpp b/displayengine/libs/hwc/hwc_display_virtual.cpp
index 9601e63..acd7948 100644
--- a/displayengine/libs/hwc/hwc_display_virtual.cpp
+++ b/displayengine/libs/hwc/hwc_display_virtual.cpp
@@ -28,7 +28,6 @@
*/
#include <utils/constants.h>
-#include <gralloc_priv.h>
#include <sync/sync.h>
#include "hwc_display_virtual.h"
@@ -71,6 +70,11 @@
int HWCDisplayVirtual::Prepare(hwc_display_contents_1_t *content_list) {
int status = 0;
+ if (display_paused_) {
+ MarkLayersForGPUBypass(content_list);
+ return status;
+ }
+
status = AllocateLayerStack(content_list);
if (status) {
return status;
@@ -91,6 +95,22 @@
int HWCDisplayVirtual::Commit(hwc_display_contents_1_t *content_list) {
int status = 0;
+ if (display_paused_) {
+ if (content_list->outbufAcquireFenceFd >= 0) {
+ // If we do not handle the frame set retireFenceFd to outbufAcquireFenceFd,
+ // which will make sure the framework waits on it and closes it.
+ content_list->retireFenceFd = dup(content_list->outbufAcquireFenceFd);
+ close(content_list->outbufAcquireFenceFd);
+ content_list->outbufAcquireFenceFd = -1;
+ }
+ CloseAcquireFences(content_list);
+
+ DisplayError error = display_intf_->Flush();
+ if (error != kErrorNone) {
+ DLOGE("Flush failed. Error = %d", error);
+ }
+ return status;
+ }
status = HWCDisplay::CommitLayerStack(content_list);
if (status) {
@@ -124,13 +144,15 @@
return -EINVAL;
}
- if ((output_handle->width != INT(output_buffer_->width)) ||
- (output_handle->height != INT(output_buffer_->height)) ||
+ int active_width = GetWidth(output_handle);
+ int active_height = GetHeight(output_handle);
+
+ if ((active_width != INT(output_buffer_->width)) ||
+ (active_height!= INT(output_buffer_->height)) ||
(format != output_buffer_->format)) {
DisplayConfigVariableInfo variable_info;
-
- variable_info.x_pixels = output_handle->width;
- variable_info.y_pixels = output_handle->height;
+ variable_info.x_pixels = active_width;
+ variable_info.y_pixels = active_height;
// TODO(user): Need to get the framerate of primary display and update it.
variable_info.fps = 60;
@@ -164,8 +186,8 @@
return -EINVAL;
}
- output_buffer_->width = output_handle->width;
- output_buffer_->height = output_handle->height;
+ output_buffer_->width = GetWidth(output_handle);
+ output_buffer_->height = GetHeight(output_handle);
output_buffer_->flags.secure = 0;
output_buffer_->flags.video = 0;
@@ -234,5 +256,23 @@
DLOGI("output_layer_dump_enable %d", dump_output_layer_);
}
+int HWCDisplayVirtual::GetWidth(const private_handle_t* handle) {
+ MetaData_t *metadata = reinterpret_cast<MetaData_t *>(handle->base_metadata);
+ if (metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
+ return metadata->bufferDim.sliceWidth;
+ }
+
+ return handle->width;
+}
+
+int HWCDisplayVirtual::GetHeight(const private_handle_t* handle) {
+ MetaData_t *metadata = reinterpret_cast<MetaData_t *>(handle->base_metadata);
+ if (metadata && metadata->operation & UPDATE_BUFFER_GEOMETRY) {
+ return metadata->bufferDim.sliceHeight;
+ }
+
+ return handle->height;
+}
+
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_display_virtual.h b/displayengine/libs/hwc/hwc_display_virtual.h
index 7ac7c22..3042b12 100644
--- a/displayengine/libs/hwc/hwc_display_virtual.h
+++ b/displayengine/libs/hwc/hwc_display_virtual.h
@@ -25,6 +25,8 @@
#ifndef __HWC_DISPLAY_VIRTUAL_H__
#define __HWC_DISPLAY_VIRTUAL_H__
+#include <qdMetaData.h>
+#include <gralloc_priv.h>
#include "hwc_display.h"
namespace sde {
@@ -42,6 +44,8 @@
private:
int SetOutputBuffer(hwc_display_contents_1_t *content_list);
void DumpOutputBuffer(hwc_display_contents_1_t *content_list);
+ int GetWidth(const private_handle_t* handle);
+ int GetHeight(const private_handle_t* handle);
bool dump_output_layer_;
};
diff --git a/displayengine/libs/hwc/hwc_session.cpp b/displayengine/libs/hwc/hwc_session.cpp
index 2201aa6..f69ddfa 100644
--- a/displayengine/libs/hwc/hwc_session.cpp
+++ b/displayengine/libs/hwc/hwc_session.cpp
@@ -28,14 +28,19 @@
*/
#include <core/dump_interface.h>
+#include <core/buffer_allocator.h>
#include <utils/constants.h>
#include <utils/String16.h>
+#include <cutils/properties.h>
#include <hardware_legacy/uevent.h>
#include <sys/resource.h>
#include <sys/prctl.h>
#include <binder/Parcel.h>
#include <QService.h>
+#include <gr.h>
+#include <gralloc_priv.h>
#include <core/buffer_allocator.h>
+#include <display_config.h>
#include "hwc_buffer_allocator.h"
#include "hwc_buffer_sync_handler.h"
@@ -153,6 +158,8 @@
return -errno;
}
+ SetFrameBufferResolution(HWC_DISPLAY_PRIMARY, NULL);
+
return 0;
}
@@ -240,10 +247,13 @@
}
break;
case HWC_DISPLAY_VIRTUAL:
+ if (hwc_session->display_external_) {
+ break;
+ }
if (hwc_session->ValidateContentList(content_list)) {
- hwc_session->CreateVirtualDisplay(hwc_session, content_list);
+ hwc_session->CreateVirtualDisplay(content_list);
} else {
- hwc_session->DestroyVirtualDisplay(hwc_session);
+ hwc_session->DestroyVirtualDisplay();
}
if (hwc_session->display_virtual_) {
@@ -284,6 +294,21 @@
}
break;
case HWC_DISPLAY_VIRTUAL:
+ if (hwc_session->display_external_) {
+ if (content_list) {
+ for (size_t i = 0; i < content_list->numHwLayers; i++) {
+ if (content_list->hwLayers[i].acquireFenceFd >= 0) {
+ close(content_list->hwLayers[i].acquireFenceFd);
+ content_list->hwLayers[i].acquireFenceFd = -1;
+ }
+ }
+ if (content_list->outbufAcquireFenceFd >= 0) {
+ close(content_list->outbufAcquireFenceFd);
+ content_list->outbufAcquireFenceFd = -1;
+ }
+ content_list->retireFenceFd = -1;
+ }
+ }
if (hwc_session->display_virtual_) {
hwc_session->display_virtual_->Commit(content_list);
}
@@ -514,49 +539,50 @@
return (content_list && content_list->numHwLayers > 0 && content_list->outbuf);
}
-int HWCSession::CreateVirtualDisplay(HWCSession *hwc_session,
- hwc_display_contents_1_t *content_list) {
+int HWCSession::CreateVirtualDisplay(hwc_display_contents_1_t *content_list) {
int status = 0;
- if (!hwc_session->display_virtual_) {
+ if (!display_virtual_) {
// Create virtual display device
- hwc_session->display_virtual_ = new HWCDisplayVirtual(hwc_session->core_intf_,
- &hwc_session->hwc_procs_);
- if (!hwc_session->display_virtual_) {
+ display_virtual_ = new HWCDisplayVirtual(core_intf_, &hwc_procs_);
+ if (!display_virtual_) {
// This is not catastrophic. Leave a warning message for now.
DLOGW("Virtual Display creation failed");
return -ENOMEM;
}
- status = hwc_session->display_virtual_->Init();
+ status = display_virtual_->Init();
if (status) {
goto CleanupOnError;
}
- status = hwc_session->display_virtual_->SetPowerMode(HWC_POWER_MODE_NORMAL);
+ status = display_virtual_->SetPowerMode(HWC_POWER_MODE_NORMAL);
if (status) {
goto CleanupOnError;
}
}
- if (hwc_session->display_virtual_) {
- status = hwc_session->display_virtual_->SetActiveConfig(content_list);
+ if (display_virtual_) {
+ SetFrameBufferResolution(HWC_DISPLAY_VIRTUAL, content_list);
+ status = display_virtual_->SetActiveConfig(content_list);
}
return status;
CleanupOnError:
- return hwc_session->DestroyVirtualDisplay(hwc_session);
+ return DestroyVirtualDisplay();
}
-int HWCSession::DestroyVirtualDisplay(HWCSession *hwc_session) {
+int HWCSession::DestroyVirtualDisplay() {
int status = 0;
- if (hwc_session->display_virtual_) {
- status = hwc_session->display_virtual_->Deinit();
+ if (display_virtual_) {
+ status = display_virtual_->Deinit();
if (!status) {
- delete hwc_session->display_virtual_;
- hwc_session->display_virtual_ = NULL;
+ delete display_virtual_;
+ display_virtual_ = NULL;
+ // Signal the HotPlug thread to continue with the external display connection
+ locker_.Signal();
}
}
@@ -600,6 +626,13 @@
case qService::IQService::SET_DISPLAY_MODE:
status = SetDisplayMode(input_parcel);
break;
+ case qService::IQService::SET_SECONDARY_DISPLAY_STATUS:
+ status = SetSecondaryDisplayStatus(input_parcel);
+ break;
+
+ case qService::IQService::CONFIGURE_DYN_REFRESH_RATE:
+ status = ConfigureRefreshRate(input_parcel);
+ break;
default:
DLOGW("QService command = %d is not supported", command);
@@ -609,6 +642,55 @@
return status;
}
+android::status_t HWCSession::SetSecondaryDisplayStatus(const android::Parcel *input_parcel) {
+ uint32_t display_id = UINT32(input_parcel->readInt32());
+ uint32_t display_status = UINT32(input_parcel->readInt32());
+ HWCDisplay *display = NULL;
+
+ DLOGI("Display %d Status %d", display_id, display_status);
+ switch (display_id) {
+ case HWC_DISPLAY_EXTERNAL:
+ display = display_external_;
+ break;
+ case HWC_DISPLAY_VIRTUAL:
+ display = display_virtual_;
+ break;
+ default:
+ DLOGW("Not supported for display %d", display_id);
+ return -EINVAL;
+ }
+
+ return display->SetDisplayStatus(display_status);
+}
+
+android::status_t HWCSession::ConfigureRefreshRate(const android::Parcel *input_parcel) {
+ uint32_t operation = UINT32(input_parcel->readInt32());
+
+ switch (operation) {
+ case qdutils::DISABLE_METADATA_DYN_REFRESH_RATE:
+ display_primary_->SetMetaDataRefreshRateFlag(false);
+ break;
+
+ case qdutils::ENABLE_METADATA_DYN_REFRESH_RATE:
+ display_primary_->SetMetaDataRefreshRateFlag(true);
+ break;
+
+ case qdutils::SET_BINDER_DYN_REFRESH_RATE:
+ {
+ uint32_t refresh_rate = UINT32(input_parcel->readInt32());
+
+ display_primary_->SetRefreshRate(refresh_rate);
+ break;
+ }
+
+ default:
+ DLOGW("Invalid operation %d", operation);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
android::status_t HWCSession::SetDisplayMode(const android::Parcel *input_parcel) {
DisplayError error = kErrorNone;
uint32_t mode = UINT32(input_parcel->readInt32());
@@ -753,8 +835,9 @@
if (hwc_procs_) {
reset_panel_ = true;
hwc_procs_->invalidate(hwc_procs_);
- } else
+ } else {
DLOGW("Ignore resetpanel - hwc_proc not registered");
+ }
}
}
}
@@ -782,19 +865,19 @@
DLOGI("Powering off primary");
status = display_primary_->SetPowerMode(HWC_POWER_MODE_OFF);
if (status) {
- DLOGE("power-off on primary failed with error = %d",status);
+ DLOGE("power-off on primary failed with error = %d", status);
}
DLOGI("Restoring power mode on primary");
uint32_t mode = display_primary_->GetLastPowerMode();
status = display_primary_->SetPowerMode(mode);
if (status) {
- DLOGE("Setting power mode = %d on primary failed with error = %d", mode,status);
+ DLOGE("Setting power mode = %d on primary failed with error = %d", mode, status);
}
status = display_primary_->EventControl(HWC_EVENT_VSYNC, 1);
if (status) {
- DLOGE("enabling vsync failed for primary with error = %d",status);
+ DLOGE("enabling vsync failed for primary with error = %d", status);
}
reset_panel_ = false;
@@ -808,6 +891,14 @@
if (connected) {
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
+ if (display_virtual_) {
+ // Wait for the virtual display to tear down
+ int status = locker_.WaitFinite(kExternalConnectionTimeoutMs);
+ if (status != 0) {
+ DLOGE("Timed out while waiting for virtual display to tear down.");
+ return -1;
+ }
+ }
if (display_external_) {
DLOGE("HDMI already connected");
return -1;
@@ -823,6 +914,7 @@
display_external_ = NULL;
return -1;
}
+ SetFrameBufferResolution(HWC_DISPLAY_EXTERNAL, NULL);
} else {
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
if (!display_external_) {
@@ -842,5 +934,72 @@
return 0;
}
+void HWCSession::SetFrameBufferResolution(int disp, hwc_display_contents_1_t *content_list) {
+ char property[PROPERTY_VALUE_MAX];
+ uint32_t primary_width = 0;
+ uint32_t primary_height = 0;
+
+ switch (disp) {
+ case HWC_DISPLAY_PRIMARY:
+ {
+ display_primary_->GetPanelResolution(&primary_width, &primary_height);
+ if (property_get("debug.hwc.fbsize", property, NULL) > 0) {
+ char *yptr = strcasestr(property, "x");
+ primary_width = atoi(property);
+ primary_height = atoi(yptr + 1);
+ }
+ display_primary_->SetFrameBufferResolution(primary_width, primary_height);
+ break;
+ }
+
+ case HWC_DISPLAY_EXTERNAL:
+ {
+ uint32_t external_width = 0;
+ uint32_t external_height = 0;
+ display_external_->GetPanelResolution(&external_width, &external_height);
+
+ if (property_get("sys.hwc.mdp_downscale_enabled", property, "false") &&
+ !strcmp(property, "true")) {
+ display_primary_->GetFrameBufferResolution(&primary_width, &primary_height);
+ uint32_t primary_area = primary_width * primary_height;
+ uint32_t external_area = external_width * external_height;
+
+ if (primary_area > external_area) {
+ if (primary_height > primary_width) {
+ Swap(primary_height, primary_width);
+ }
+ AdjustSourceResolution(primary_width, primary_height,
+ &external_width, &external_height);
+ }
+ }
+ display_external_->SetFrameBufferResolution(external_width, external_height);
+ break;
+ }
+
+ case HWC_DISPLAY_VIRTUAL:
+ {
+ if (ValidateContentList(content_list)) {
+ const private_handle_t *output_handle =
+ static_cast<const private_handle_t *>(content_list->outbuf);
+ int virtual_width = 0;
+ int virtual_height = 0;
+ getBufferSizeAndDimensions(output_handle->width, output_handle->height, output_handle->format,
+ virtual_width, virtual_height);
+ display_virtual_->SetFrameBufferResolution(virtual_width, virtual_height);
+ }
+ break;
+ }
+
+ default:
+ break;
+ }
+}
+
+void HWCSession::AdjustSourceResolution(uint32_t dst_width, uint32_t dst_height,
+ uint32_t *src_width, uint32_t *src_height) {
+ *src_height = (dst_width * (*src_height)) / (*src_width);
+ *src_width = dst_width;
+}
+
} // namespace sde
diff --git a/displayengine/libs/hwc/hwc_session.h b/displayengine/libs/hwc/hwc_session.h
index dffa864..fbb3f43 100644
--- a/displayengine/libs/hwc/hwc_session.h
+++ b/displayengine/libs/hwc/hwc_session.h
@@ -49,6 +49,8 @@
int Deinit();
private:
+ static const int kExternalConnectionTimeoutMs = 500;
+
// hwc methods
static int Open(const hw_module_t *module, const char* name, hw_device_t **device);
static int Close(hw_device_t *device);
@@ -75,8 +77,8 @@
int HotPlugHandler(bool connected);
void ResetPanel();
bool ValidateContentList(hwc_display_contents_1_t *content_list);
- int CreateVirtualDisplay(HWCSession *hwc_session, hwc_display_contents_1_t *content_list);
- int DestroyVirtualDisplay(HWCSession *hwc_session);
+ int CreateVirtualDisplay(hwc_display_contents_1_t *content_list);
+ int DestroyVirtualDisplay();
// CoreEventHandler methods
virtual DisplayError Hotplug(const CoreEventHotplug &hotplug);
@@ -88,6 +90,11 @@
void SetFrameDumpConfig(const android::Parcel *input_parcel);
android::status_t SetMaxMixerStages(const android::Parcel *input_parcel);
android::status_t SetDisplayMode(const android::Parcel *input_parcel);
+ android::status_t SetSecondaryDisplayStatus(const android::Parcel *input_parcel);
+ void SetFrameBufferResolution(int disp, hwc_display_contents_1_t *content_list);
+ void AdjustSourceResolution(uint32_t dst_width, uint32_t dst_height,
+ uint32_t *src_width, uint32_t *src_height);
+ android::status_t ConfigureRefreshRate(const android::Parcel *input_parcel);
static Locker locker_;
CoreInterface *core_intf_;
diff --git a/displayengine/libs/utils/debug_android.cpp b/displayengine/libs/utils/debug_android.cpp
index 77c82b0..779c441 100644
--- a/displayengine/libs/utils/debug_android.cpp
+++ b/displayengine/libs/utils/debug_android.cpp
@@ -90,7 +90,7 @@
}
// This property serves to disable/enable partial update
-bool Debug::IsPartialUpdate() {
+bool Debug::IsPartialUpdateEnabled() {
char property[PROPERTY_VALUE_MAX];
if (property_get("sde.hwc.partial_update", property, NULL) > 0) {
return (atoi(property) ? 1 : true, false);
diff --git a/displayengine/libs/utils/rect.cpp b/displayengine/libs/utils/rect.cpp
index 9b05951..630cebb 100644
--- a/displayengine/libs/utils/rect.cpp
+++ b/displayengine/libs/utils/rect.cpp
@@ -122,11 +122,11 @@
return LayerRect();
}
- if(!IsValid(rect1)){
+ if (!IsValid(rect1)) {
return rect2;
}
- if(!IsValid(rect2)){
+ if (!IsValid(rect2)) {
return rect1;
}
diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
index 3ed4934..695de9b 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -153,15 +153,17 @@
int usage, int& aligned_w, int& aligned_h)
{
+ bool ubwc_enabled = isUBwcEnabled(format, usage);
+
// Currently surface padding is only computed for RGB* surfaces.
if (format <= HAL_PIXEL_FORMAT_sRGB_X_8888) {
- int tileEnabled = isMacroTileEnabled(format, usage);
+ int tileEnabled = ubwc_enabled || isMacroTileEnabled(format, usage);
AdrenoMemInfo::getInstance().getGpuAlignedWidthHeight(width,
height, format, tileEnabled, aligned_w, aligned_h);
return;
}
- if (isUBwcEnabled(format, usage)) {
+ if (ubwc_enabled) {
getUBwcWidthAndHeight(width, height, format, aligned_w, aligned_h);
return;
}
@@ -172,9 +174,11 @@
{
case HAL_PIXEL_FORMAT_YCrCb_420_SP:
case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:
- case HAL_PIXEL_FORMAT_RAW_SENSOR:
aligned_w = ALIGN(width, 32);
break;
+ case HAL_PIXEL_FORMAT_RAW_SENSOR:
+ aligned_w = ALIGN(width, 16);
+ break;
case HAL_PIXEL_FORMAT_RAW10:
aligned_w = ALIGN(width * 10 /8, 16);
break;
@@ -627,9 +631,9 @@
void getBufferAttributes(int width, int height, int format, int usage,
- int& alignedw, int &alignedh, int& tileEnabled, unsigned int& size)
+ int& alignedw, int &alignedh, int& tiled, unsigned int& size)
{
- tileEnabled = isMacroTileEnabled(format, usage);
+ tiled = isUBwcEnabled(format, usage) || isMacroTileEnabled(format, usage);
AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
height,
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index 11d8f1f..256b023 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -148,6 +148,7 @@
if (isUBwcEnabled(format, usage) &&
AdrenoMemInfo::getInstance().isUBWCSupportedByGPU(format)) {
flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
+ flags |= private_handle_t::PRIV_FLAGS_TILE_RENDERED;
}
if(usage & (GRALLOC_USAGE_SW_READ_MASK | GRALLOC_USAGE_SW_WRITE_MASK)) {
diff --git a/libgralloc/mapper.cpp b/libgralloc/mapper.cpp
index 30f606e..cf365ce 100644
--- a/libgralloc/mapper.cpp
+++ b/libgralloc/mapper.cpp
@@ -386,7 +386,8 @@
int *alignedWidth = va_arg(args, int *);
int *alignedHeight = va_arg(args, int *);
int *tileEnabled = va_arg(args,int *);
- *tileEnabled = isMacroTileEnabled(format, usage);
+ *tileEnabled = isUBwcEnabled(format, usage) ||
+ isMacroTileEnabled(format, usage);
AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width,
height, format, usage, *alignedWidth, *alignedHeight);
res = 0;
diff --git a/libhwcomposer/hwc_copybit.cpp b/libhwcomposer/hwc_copybit.cpp
index 00bd643..e7c2928 100644
--- a/libhwcomposer/hwc_copybit.cpp
+++ b/libhwcomposer/hwc_copybit.cpp
@@ -82,6 +82,29 @@
return true;
}
+bool CopyBit::isSmartBlitPossible(const hwc_display_contents_1_t *list){
+ if(list->numHwLayers > 2) {
+ hwc_rect_t displayFrame0 = {0, 0, 0, 0};
+ hwc_rect_t displayFrame1 = {0, 0, 0, 0};
+ for (unsigned int i=0; i<list->numHwLayers -1; i++) {
+ hwc_rect_t displayFrame = getIntersection(mDirtyRect,
+ list->hwLayers[i].displayFrame);
+ if (isValidRect(displayFrame) && !isValidRect(displayFrame0)) {
+ displayFrame0 = displayFrame;
+ } else if(isValidRect(displayFrame)) {
+ displayFrame1 = displayFrame;
+ break;
+ }
+ }
+ if((displayFrame0 == displayFrame1) &&
+ not (list->flags & (MDP_ROT_90 | MDP_FLIP_UD | MDP_FLIP_LR))) {
+ ALOGD_IF (DEBUG_COPYBIT, "%s:Smart Bilt Possible",__FUNCTION__);
+ return true;
+ }
+ }
+ return false;
+}
+
bool CopyBit::canUseCopybitForRGB(hwc_context_t *ctx,
hwc_display_contents_1_t *list,
int dpy) {
@@ -99,7 +122,11 @@
unsigned int renderArea = getRGBRenderingArea(ctx, list);
ALOGD_IF (DEBUG_COPYBIT, "%s:renderArea %u, fbArea %u",
__FUNCTION__, renderArea, fbArea);
- if (renderArea < (mDynThreshold * fbArea)) {
+ double dynThreshold = mDynThreshold;
+ if(not isSmartBlitPossible(list))
+ dynThreshold -= 1;
+
+ if (renderArea < (dynThreshold * fbArea)) {
return true;
}
} else if ((compositionType & qdutils::COMPOSITION_TYPE_MDP)) {
@@ -148,16 +175,19 @@
return 0;
}
-int CopyBit::getLayersChanging(hwc_context_t *ctx,
- hwc_display_contents_1_t *list,
- int dpy){
-
- int changingLayerIndex = -1;
- if(mLayerCache.layerCount != ctx->listStats[dpy].numAppLayers) {
+bool CopyBit::prepareSwapRect(hwc_context_t *ctx,
+ hwc_display_contents_1_t *list,
+ int dpy) {
+ bool canUseSwapRect = 0;
+ hwc_rect_t dirtyRect = {0, 0, 0, 0};
+ hwc_rect_t displayRect = {0, 0, 0, 0};
+ if((mLayerCache.layerCount != ctx->listStats[dpy].numAppLayers) ||
+ not mSwapRectEnable) {
mLayerCache.reset();
mFbCache.reset();
mLayerCache.updateCounts(ctx,list,dpy);
- return -1;
+ mDirtyRect = displayRect;
+ return 0;
}
int updatingLayerCount = 0;
@@ -165,8 +195,10 @@
//swap rect will kick in only for single updating layer
if(isLayerChanging(ctx, list, k)) {
updatingLayerCount ++;
- if(updatingLayerCount == 1)
- changingLayerIndex = k;
+ hwc_layer_1_t layer = list->hwLayers[k];
+ canUseSwapRect = 1;
+ dirtyRect = getUnion(dirtyRect, layer.dirtyRect);
+ displayRect = getUnion(displayRect, layer.displayFrame);
}
}
//since we are using more than one framebuffers,we have to
@@ -174,19 +206,13 @@
//dirty rect for same layer at least equal of number of
//framebuffers
- if ( updatingLayerCount <= 1 ) {
- hwc_rect_t dirtyRect;
+ if (canUseSwapRect || updatingLayerCount == 0) {
if (updatingLayerCount == 0) {
dirtyRect.left = INVALID_DIMENSION;
dirtyRect.top = INVALID_DIMENSION;
dirtyRect.right = INVALID_DIMENSION;
dirtyRect.bottom = INVALID_DIMENSION;
- changingLayerIndex = NO_UPDATING_LAYER;
- } else {
- dirtyRect = list->hwLayers[changingLayerIndex].displayFrame;
-#ifdef QCOM_BSP
- dirtyRect = list->hwLayers[changingLayerIndex].dirtyRect;
-#endif
+ canUseSwapRect = 1;
}
for (int k = ctx->listStats[dpy].numAppLayers-1; k >= 0 ; k--) {
@@ -195,34 +221,36 @@
if(needsScaling(&list->hwLayers[k])||( hnd && isYuvBuffer(hnd)) ||
(list->hwLayers[k].transform & HAL_TRANSFORM_ROT_90)) {
mFbCache.reset();
- return -1;
+ displayRect.bottom = 0;
+ displayRect.top = 0;
+ displayRect.right = 0;
+ displayRect.bottom = 0;
+ mDirtyRect = displayRect;
+ return 0;
}
}
- hwc_rect_t displayRect = list->hwLayers[changingLayerIndex].displayFrame;
+
if(mFbCache.getUnchangedFbDRCount(dirtyRect, displayRect) <
NUM_RENDER_BUFFERS) {
mFbCache.insertAndUpdateFbCache(dirtyRect, displayRect);
- changingLayerIndex = -1;
+ canUseSwapRect = 0;
+ displayRect.bottom = 0;
+ displayRect.top = 0;
+ displayRect.right = 0;
+ displayRect.bottom = 0;
}
} else {
mFbCache.reset();
- changingLayerIndex = -1;
+ canUseSwapRect = 0;
+ displayRect.bottom = 0;
+ displayRect.top = 0;
+ displayRect.right = 0;
+ displayRect.bottom = 0;
+
}
+ mDirtyRect = displayRect;
mLayerCache.updateCounts(ctx,list,dpy);
- return changingLayerIndex;
-}
-
-int CopyBit::checkDirtyRect(hwc_context_t *ctx,
- hwc_display_contents_1_t *list,
- int dpy) {
-
- //dirty rect will enable only if
- //1.Only single layer is updating.
- //2.No scaling
- //3.No video layer
- if(mSwapRectEnable == false)
- return -1;
- return getLayersChanging(ctx, list, dpy);
+ return canUseSwapRect;
}
bool CopyBit::prepareOverlap(hwc_context_t *ctx,
@@ -326,6 +354,13 @@
return false;
}
+ int last = (uint32_t)list->numHwLayers - 1;
+ mDirtyRect = list->hwLayers[last].displayFrame;
+ mSwapRect = prepareSwapRect(ctx, list, dpy);
+ ALOGD_IF (DEBUG_COPYBIT, "%s: mSwapRect: %d mDirtyRect: [%d, %d, %d, %d]",
+ __FUNCTION__, mSwapRect, mDirtyRect.left,
+ mDirtyRect.top, mDirtyRect.right, mDirtyRect.bottom);
+
bool useCopybitForYUV = canUseCopybitForYUV(ctx);
bool useCopybitForRGB = canUseCopybitForRGB(ctx, list, dpy);
LayerProp *layerProp = ctx->layerProp[dpy];
@@ -498,7 +533,7 @@
list->hwLayers[abcRenderBufIdx].acquireFenceFd);
}
for(int i = abcRenderBufIdx + 1; i < layerCount; i++){
- mDirtyLayerIndex = -1;
+ mSwapRect = 0;
int retVal = drawLayerUsingCopybit(ctx,
&(list->hwLayers[i]),renderBuffer, 0);
if(retVal < 0) {
@@ -559,33 +594,9 @@
}
}
- mDirtyLayerIndex = checkDirtyRect(ctx, list, dpy);
- ALOGD_IF (DEBUG_COPYBIT, "%s:Dirty Layer Index: %d",
- __FUNCTION__, mDirtyLayerIndex);
-
- hwc_rect_t clearRegion = {0,0,0,0};
- mDirtyRect = list->hwLayers[last].displayFrame;
-
- if (mDirtyLayerIndex != NO_UPDATING_LAYER &&
- CBUtils::getuiClearRegion(list, clearRegion, layerProp,
- mDirtyLayerIndex)) {
- int clear_w = clearRegion.right - clearRegion.left;
- int clear_h = clearRegion.bottom - clearRegion.top;
- //mdp can't handle solid fill for one line
- //making solid fill as full in this case
- //disable swap rect if presents
- if ((clear_w == 1) || (clear_h ==1)) {
- clear(renderBuffer, mDirtyRect);
- mDirtyLayerIndex = -1;
- }else
- clear(renderBuffer, clearRegion);
- }
- if (mDirtyLayerIndex != -1) {
- if (mDirtyLayerIndex == NO_UPDATING_LAYER) {
- mDirtyRect = clearRegion;
- } else {
- mDirtyRect = list->hwLayers[mDirtyLayerIndex].displayFrame;
- }
+ if (not CBUtils::uiClearRegion(list, ctx->mMDP.version, layerProp,
+ mDirtyRect, mEngine, renderBuffer)){
+ mSwapRect = 0;
}
// numAppLayers-1, as we iterate from 0th layer index with HWC_COPYBIT flag
@@ -648,10 +659,10 @@
}
//Clear the transparent or left out region on the render buffer
- hwc_rect_t clearRegion = {0,0,0,0};
LayerProp *layerProp = ctx->layerProp[0];
- if(CBUtils::getuiClearRegion(list, clearRegion, layerProp))
- clear(renderBuffer, clearRegion);
+ hwc_rect_t clearRegion = {0, 0, 0, 0};
+ CBUtils::uiClearRegion(list, ctx->mMDP.version, layerProp, clearRegion,
+ mEngine, renderBuffer);
int copybitLayerCount = 0;
for(int j = 0; j < ptorInfo->count; j++) {
@@ -901,7 +912,7 @@
displayFrame.bottom};
#ifdef QCOM_BSP
//change src and dst with dirtyRect
- if(mDirtyLayerIndex != -1) {
+ if(mSwapRect) {
hwc_rect_t result = getIntersection(displayFrame, mDirtyRect);
if(!isValidRect(result))
return true;
@@ -1147,9 +1158,10 @@
unsigned int& width, unsigned int& height)
{
hwc_rect_t displayFrame = layer->displayFrame;
+ hwc_rect_t result = getIntersection(mDirtyRect, displayFrame);
- width = displayFrame.right - displayFrame.left;
- height = displayFrame.bottom - displayFrame.top;
+ width = result.right - result.left;
+ height = result.bottom - result.top;
}
bool CopyBit::validateParams(hwc_context_t *ctx,
@@ -1238,7 +1250,7 @@
property_get("debug.sf.swaprect", value, "0");
mSwapRectEnable = atoi(value) ? true:false ;
- mDirtyLayerIndex = -1;
+ mSwapRect = 0;
if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) {
if(copybit_open(module, &mEngine) < 0) {
ALOGE("FATAL ERROR: copybit open failed.");
diff --git a/libhwcomposer/hwc_copybit.h b/libhwcomposer/hwc_copybit.h
index 993c790..a1601cc 100644
--- a/libhwcomposer/hwc_copybit.h
+++ b/libhwcomposer/hwc_copybit.h
@@ -131,16 +131,15 @@
bool mSwapRectEnable;
int mAlignedWidth;
int mAlignedHeight;
- int mDirtyLayerIndex;
+ int mSwapRect;
LayerCache mLayerCache;
FbCache mFbCache;
hwc_rect_t mDirtyRect;
- int getLayersChanging(hwc_context_t *ctx, hwc_display_contents_1_t *list,
- int dpy);
- int checkDirtyRect(hwc_context_t *ctx, hwc_display_contents_1_t *list,
+ bool prepareSwapRect(hwc_context_t *ctx, hwc_display_contents_1_t *list,
int dpy);
bool isLayerChanging(hwc_context_t *ctx,
hwc_display_contents_1_t *list, int k);
+ bool isSmartBlitPossible(const hwc_display_contents_1_t *list);
};
}; //namespace qhwc
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index 79235ff..5de3081 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -967,6 +967,9 @@
src_w = sourceCrop.right - sourceCrop.left;
src_h = sourceCrop.bottom - sourceCrop.top;
+ if(layer->transform & HWC_TRANSFORM_ROT_90)
+ swap(src_w, src_h);
+
if(((src_w > dst_w) || (src_h > dst_h)))
return true;
@@ -982,6 +985,10 @@
dst_h = displayFrame.bottom - displayFrame.top;
src_w = sourceCrop.right - sourceCrop.left;
src_h = sourceCrop.bottom - sourceCrop.top;
+
+ if(layer->transform & HWC_TRANSFORM_ROT_90)
+ swap(src_w, src_h);
+
if(dst_w && dst_h) {
float w_scale = ((float)src_w / (float)dst_w);
float h_scale = ((float)src_h / (float)dst_h);
diff --git a/liblight/lights.c b/liblight/lights.c
index 615ddd8..12af384 100644
--- a/liblight/lights.c
+++ b/liblight/lights.c
@@ -162,7 +162,16 @@
blue = colorRGB & 0xFF;
if (onMS > 0 && offMS > 0) {
- blink = 1;
+ /*
+ * if ON time == OFF time
+ * use blink mode 2
+ * else
+ * use blink mode 1
+ */
+ if (onMS == offMS)
+ blink = 2;
+ else
+ blink = 1;
} else {
blink = 0;
}
diff --git a/libqdutils/cb_utils.cpp b/libqdutils/cb_utils.cpp
index c17842a..b85b901 100644
--- a/libqdutils/cb_utils.cpp
+++ b/libqdutils/cb_utils.cpp
@@ -36,37 +36,39 @@
irect.bottom = max(rect1.bottom, rect2.bottom);
}
+int clear (copybit_device_t *copybit, private_handle_t* hnd, hwc_rect_t& rect)
+{
+ int ret = 0;
+ copybit_rect_t clear_rect = {rect.left, rect.top,rect.right,rect.bottom};
+
+ copybit_image_t buf;
+ buf.w = ALIGN(getWidth(hnd),32);
+ buf.h = getHeight(hnd);
+ buf.format = hnd->format;
+ buf.base = (void *)hnd->base;
+ buf.handle = (native_handle_t *)hnd;
+
+ ret = copybit->clear(copybit, &buf, &clear_rect);
+ return ret;
+}
using namespace android;
using namespace qhwc;
namespace qdutils {
-int CBUtils::getuiClearRegion(hwc_display_contents_1_t* list,
- hwc_rect_t &clearWormholeRect, LayerProp *layerProp, int dirtyIndex) {
+int CBUtils::uiClearRegion(hwc_display_contents_1_t* list,
+ int version, LayerProp *layerProp, hwc_rect_t dirtyRect,
+ copybit_device_t *copybit, private_handle_t *renderBuffer) {
size_t last = list->numHwLayers - 1;
hwc_rect_t fbFrame = list->hwLayers[last].displayFrame;
Rect fbFrameRect(fbFrame.left,fbFrame.top,fbFrame.right,fbFrame.bottom);
Region wormholeRegion(fbFrameRect);
- if (dirtyIndex != -1) {
+ if ((dirtyRect.right - dirtyRect.left > 0) &&
+ (dirtyRect.bottom - dirtyRect.top > 0)) {
#ifdef QCOM_BSP
- /*
- * 1. Map dirty rect of updating layer to its display frame.
- * 2. Use this display frame as wormholeRegion instead of full Frame
- * */
- hwc_rect_t dirtyRect = list->hwLayers[dirtyIndex].dirtyRect;
- hwc_rect_t displayFrame = list->hwLayers[dirtyIndex].displayFrame;
- hwc_frect_t sCropF = list->hwLayers[dirtyIndex].sourceCropf;
- hwc_rect_t srcRect = {int(ceilf(sCropF.left)), int(ceilf(sCropF.top)),
- int(ceilf(sCropF.right)), int(ceilf(sCropF.bottom))};
-
- displayFrame.left += dirtyRect.left - srcRect.left;
- displayFrame.top += dirtyRect.top - srcRect.top;
- displayFrame.right -= srcRect.right - dirtyRect.right;
- displayFrame.bottom -= srcRect.bottom - dirtyRect.bottom;
-
- Rect tmpRect(displayFrame.left,displayFrame.top,displayFrame.right,
- displayFrame.bottom);
+ Rect tmpRect(dirtyRect.left,dirtyRect.top,dirtyRect.right,
+ dirtyRect.bottom);
Region tmpRegion(tmpRect);
wormholeRegion = wormholeRegion.intersect(tmpRegion);
#endif
@@ -100,7 +102,7 @@
}
}
if(wormholeRegion.isEmpty()){
- return 0;
+ return 1;
}
//TO DO :- 1. remove union and call clear for each rect.
Region::const_iterator it = wormholeRegion.begin();
@@ -108,14 +110,22 @@
while (it != end) {
const Rect& r = *it++;
hwc_rect_t tmpWormRect = {r.left,r.top,r.right,r.bottom};
- int dst_w = clearWormholeRect.right - clearWormholeRect.left;
- int dst_h = clearWormholeRect.bottom - clearWormholeRect.top;
-
- if (!(dst_w || dst_h))
- clearWormholeRect = tmpWormRect;
- else
- getUnion(clearWormholeRect, tmpWormRect, clearWormholeRect);
-
+ if (version == qdutils::MDP_V3_0_4 ||
+ version == qdutils::MDP_V3_0_5) {
+ int clear_w = tmpWormRect.right - tmpWormRect.left;
+ int clear_h = tmpWormRect.bottom - tmpWormRect.top;
+ //mdp can't handle solid fill for one line
+ //making solid fill as full in this case
+ //disable swap rect if presents
+ if ((clear_w == 1) || (clear_h ==1)) {
+ clear(copybit, renderBuffer, fbFrame);
+ return 0;
+ } else {
+ clear(copybit, renderBuffer, tmpWormRect);
+ }
+ } else {
+ clear(copybit, renderBuffer, tmpWormRect);
+ }
}
return 1;
}
diff --git a/libqdutils/cb_utils.h b/libqdutils/cb_utils.h
index 59f452b..55225b6 100644
--- a/libqdutils/cb_utils.h
+++ b/libqdutils/cb_utils.h
@@ -31,14 +31,15 @@
#include <ui/Region.h>
#include "hwc_utils.h"
+#include "copybit.h"
using namespace qhwc;
namespace qdutils {
class CBUtils {
public:
-static int getuiClearRegion(hwc_display_contents_1_t* list,
- hwc_rect_t &clearWormholeRec,
- LayerProp *layerProp, int dirtyIndex = -1);
+ static int uiClearRegion(hwc_display_contents_1_t* list,
+ int version, LayerProp *layerProp, hwc_rect_t dirtyIndex,
+ copybit_device_t *copybit, private_handle_t *renderBuffer);
};
}//namespace qdutils
#endif /* end of include guard: CB_UTIL_H*/