Merge "hwc: Calculate true rendering area to be blitted using MDP"
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..8c56799 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,6 +230,31 @@
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);
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 487cd56..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;
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 450565e..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;
}
@@ -556,6 +563,7 @@
}
if (display_virtual_) {
+ SetFrameBufferResolution(HWC_DISPLAY_VIRTUAL, content_list);
status = display_virtual_->SetActiveConfig(content_list);
}
@@ -618,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);
@@ -627,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());
@@ -771,8 +835,9 @@
if (hwc_procs_) {
reset_panel_ = true;
hwc_procs_->invalidate(hwc_procs_);
- } else
+ } else {
DLOGW("Ignore resetpanel - hwc_proc not registered");
+ }
}
}
}
@@ -800,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;
@@ -849,6 +914,7 @@
display_external_ = NULL;
return -1;
}
+ SetFrameBufferResolution(HWC_DISPLAY_EXTERNAL, NULL);
} else {
SEQUENCE_WAIT_SCOPE_LOCK(locker_);
if (!display_external_) {
@@ -868,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 54ab852..fbb3f43 100644
--- a/displayengine/libs/hwc/hwc_session.h
+++ b/displayengine/libs/hwc/hwc_session.h
@@ -90,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 aaaf16b..695de9b 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -174,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;