Merge "sde: Add support for swapinterval 0"
diff --git a/common.mk b/common.mk
index 464f296..183ee99 100644
--- a/common.mk
+++ b/common.mk
@@ -29,6 +29,10 @@
common_flags += -DVENUS_COLOR_FORMAT
endif
+ifeq ($(call is-board-platform-in-list, $(MASTER_SIDE_CP_TARGET_LIST)), true)
+ common_flags += -DMASTER_SIDE_CP
+endif
+
common_deps :=
kernel_includes :=
diff --git a/displayengine/include/core/layer_buffer.h b/displayengine/include/core/layer_buffer.h
index 2ab6b29..2493c13 100644
--- a/displayengine/include/core/layer_buffer.h
+++ b/displayengine/include/core/layer_buffer.h
@@ -134,20 +134,30 @@
@sa LayerBuffer
*/
struct LayerBufferFlags {
- uint64_t secure : 1; //!< This flag shall be set by client to indicate that the buffer need
- //!< to be handled securely.
- uint64_t video : 1; //!< This flag shall be set by client to indicate that the buffer is
- //!< video/ui buffer
- uint64_t macro_tile : 1; //!< This flag shall be set by client to indicate that the buffer format
- //!< is macro tiled.
- uint64_t interlace : 1; //!< This flag shall be set by the client to indicate that the buffer
- //!< has interlaced content.
- uint64_t secure_display : 1;
- //!< This flag shall be set by the client to indicate that the secure
- //!< display session is in progress. Secure display session cannot
- //!< coexist with non-secure session.
+ union {
+ struct {
+ uint32_t secure : 1; //!< This flag shall be set by client to indicate that the
+ //!< buffer need to be handled securely.
- LayerBufferFlags() : secure(0), video(0), macro_tile(0), interlace(0), secure_display(0) { }
+ uint32_t video : 1; //!< This flag shall be set by client to indicate that the
+ //!< buffer is video/ui buffer.
+
+ uint32_t macro_tile : 1; //!< This flag shall be set by client to indicate that the
+ //!< buffer format is macro tiled.
+
+ uint32_t interlace : 1; //!< This flag shall be set by the client to indicate that
+ //!< the buffer has interlaced content.
+
+ uint32_t secure_display : 1;
+ //!< This flag shall be set by the client to indicate that the
+ //!< secure display session is in progress. Secure display
+ //!< session can not coexist with non-secure session.
+ };
+
+ uint32_t flags; //!< For initialization purpose only. Client shall not refer it directly.
+ };
+
+ LayerBufferFlags() : flags(0) { }
};
/*! @brief This structure defines a layer buffer handle which contains raw buffer and its associated
diff --git a/displayengine/include/core/layer_stack.h b/displayengine/include/core/layer_stack.h
index d85fd98..66f60e7 100644
--- a/displayengine/include/core/layer_stack.h
+++ b/displayengine/include/core/layer_stack.h
@@ -92,15 +92,22 @@
@sa LayerBuffer
*/
struct LayerFlags {
- uint64_t skip : 1; //!< This flag shall be set by client to indicate that this layer will be
- //!< handled by GPU. Display Device will not consider it for composition.
+ union {
+ struct {
+ uint32_t skip : 1; //!< This flag shall be set by client to indicate that this layer
+ //!< will be handled by GPU. Display Device will not consider it
+ //!< for composition.
- uint64_t updating : 1; //!< This flag shall be set by client to indicate that this is updating/
- //!< non-updating. so strategy manager will mark them for SDE/GPU
- //!< composition respectively when the layer stack qualifies for cache
- //!< based composition.
+ uint32_t updating : 1; //!< This flag shall be set by client to indicate that this is
+ //!< updating non-updating. so strategy manager will mark them for
+ //!< SDE/GPU composition respectively when the layer stack qualifies
+ //!< for cache based composition.
+ };
- LayerFlags() : skip(0), updating(0) { }
+ uint32_t flags; //!< For initialization purpose only. Client shall not refer it directly.
+ };
+
+ LayerFlags() : flags(0) { }
};
/*! @brief This structure defines flags associated with a layer stack. The 1-bit flag can be set to
@@ -109,24 +116,29 @@
@sa LayerBuffer
*/
struct LayerStackFlags {
- uint64_t geometry_changed : 1; //!< This flag shall be set by client to indicate that the layer
- //!< set passed to Prepare() has changed by more than just the
- //!< buffer handles and acquire fences.
+ union {
+ struct {
+ uint32_t geometry_changed : 1; //!< This flag shall be set by client to indicate that the
+ //!< layer set passed to Prepare() has changed by more than
+ //!< just the buffer handles and acquire fences.
- uint64_t skip_present : 1; //!< This flag will be set to true, if the current layer stack
- //!< contains skip layers.
+ uint32_t skip_present : 1; //!< This flag will be set to true, if the current layer
+ //!< stack contains skip layers.
- uint64_t video_present : 1; //!< This flag will be set to true, if current layer stack
- //!< contains video.
+ uint32_t video_present : 1; //!< This flag will be set to true, if current layer stack
+ //!< contains video.
- uint64_t secure_present : 1; //!< This flag will be set to true, if the current layer stack
- //!< contains secure layers.
+ uint32_t secure_present : 1; //!< This flag will be set to true, if the current layer
+ //!< stack contains secure layers.
- uint64_t animating : 1; //!< This flag shall be set by client to indicate that the current
- //!< frame is animating.
+ uint32_t animating : 1; //!< This flag shall be set by client to indicate that the
+ //!< current frame is animating.
+ };
- LayerStackFlags()
- : geometry_changed(0), skip_present(0), video_present(0), secure_present(0), animating(0) { }
+ uint32_t flags; //!< For initialization purpose only. Client shall not refer it directly.
+ };
+
+ LayerStackFlags() : flags(0) { }
};
/*! @brief This structure defines a rectanglular area inside a display layer.
diff --git a/displayengine/include/private/hw_info_types.h b/displayengine/include/private/hw_info_types.h
index 49abafe..1740615 100644
--- a/displayengine/include/private/hw_info_types.h
+++ b/displayengine/include/private/hw_info_types.h
@@ -65,6 +65,7 @@
uint64_t max_bandwidth_low;
uint64_t max_bandwidth_high;
uint32_t max_mixer_width;
+ uint32_t max_pipe_width;
uint32_t max_pipe_bw;
uint32_t max_sde_clk;
float clk_fudge_factor;
@@ -81,8 +82,8 @@
num_cursor_pipe(0), num_blending_stages(0), num_rotator(0), num_control(0),
num_mixer_to_disp(0), smp_total(0), smp_size(0), num_smp_per_pipe(0), max_scale_up(1),
max_scale_down(1), max_bandwidth_low(0), max_bandwidth_high(0), max_mixer_width(2048),
- max_pipe_bw(0), max_sde_clk(0), clk_fudge_factor(1.0f), has_bwc(false), has_ubwc(false),
- has_decimation(false), has_macrotile(false), has_rotator_downscale(false),
+ max_pipe_width(2048), max_pipe_bw(0), max_sde_clk(0), clk_fudge_factor(1.0f), has_bwc(false),
+ has_ubwc(false), has_decimation(false), has_macrotile(false), has_rotator_downscale(false),
has_non_scalar_rgb(false), is_src_split(false) { }
void Reset() { *this = HWResourceInfo(); }
diff --git a/displayengine/libs/core/display_base.cpp b/displayengine/libs/core/display_base.cpp
index 8725a7b..47beac0 100644
--- a/displayengine/libs/core/display_base.cpp
+++ b/displayengine/libs/core/display_base.cpp
@@ -22,6 +22,7 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#include <stdio.h>
#include <utils/constants.h>
#include <utils/debug.h>
@@ -146,6 +147,11 @@
continue;
}
error = rotator_ctrl_->Prepare(display_rotator_ctx_, &hw_layers_);
+ } else {
+ // Release all the previous rotator sessions.
+ if (rotator_ctrl_) {
+ error = rotator_ctrl_->Purge(display_rotator_ctx_, &hw_layers_);
+ }
}
if (error == kErrorNone) {
@@ -409,9 +415,11 @@
num_modes_, active_mode_index_);
DisplayConfigVariableInfo &info = display_attributes_[active_mode_index_];
- DumpImpl::AppendString(buffer, length, "\nres:%ux%u, dpi:%.2fx%.2f, fps:%.2f, vsync period: %u",
- info.x_pixels, info.y_pixels, info.x_dpi, info.y_dpi, info.fps,
- info.vsync_period_ns);
+ DumpImpl::AppendString(buffer, length, "\nres:%u x %u, dpi:%.2f x %.2f, fps:%.2f,"
+ "vsync period: %u", info.x_pixels, info.y_pixels, info.x_dpi,
+ info.y_dpi, info.fps, info.vsync_period_ns);
+
+ DumpImpl::AppendString(buffer, length, "\n");
uint32_t num_layers = 0;
uint32_t num_hw_layers = 0;
@@ -420,64 +428,101 @@
num_hw_layers = hw_layers_.info.count;
}
- DumpImpl::AppendString(buffer, length, "\n\nnum actual layers: %u, num sde layers: %u",
- num_layers, num_hw_layers);
+ if (num_hw_layers == 0) {
+ DumpImpl::AppendString(buffer, length, "\nNo hardware layers programmed");
+ return;
+ }
+
+ HWLayersInfo &layer_info = hw_layers_.info;
+ LayerRect &l_roi = layer_info.left_partial_update;
+ LayerRect &r_roi = layer_info.right_partial_update;
+ DumpImpl::AppendString(buffer, length, "\nROI(L T R B) : LEFT(%d %d %d %d), RIGHT(%d %d %d %d)",
+ INT(l_roi.left), INT(l_roi.top), INT(l_roi.right), INT(l_roi.bottom),
+ INT(r_roi.left), INT(r_roi.top), INT(r_roi.right), INT(r_roi.bottom));
+
+ const char *header = "\n| Idx | Comp Type | Split | WB | Pipe | W x H | Format | Src Rect (L T R B) | Dst Rect (L T R B) | Z | Flags | Deci(HxV) |"; //NOLINT
+ const char *newline = "\n|-----|-------------|--------|----|-------|-------------|--------------------|---------------------|---------------------|----|------------|-----------|"; //NOLINT
+ const char *format = "\n| %3s | %11s " "| %6s " "| %2s | 0x%03x | %4d x %4d | %18s " "| %4d %4d %4d %4d " "| %4d %4d %4d %4d " "| %2s | %10s " "| %9s |"; //NOLINT
+
+ DumpImpl::AppendString(buffer, length, "\n");
+ DumpImpl::AppendString(buffer, length, newline);
+ DumpImpl::AppendString(buffer, length, header);
+ DumpImpl::AppendString(buffer, length, newline);
for (uint32_t i = 0; i < num_hw_layers; i++) {
- Layer &layer = hw_layers_.info.stack->layers[hw_layers_.info.index[i]];
+ uint32_t layer_index = hw_layers_.info.index[i];
+ Layer &layer = hw_layers_.info.stack->layers[layer_index];
LayerBuffer *input_buffer = layer.input_buffer;
HWLayerConfig &layer_config = hw_layers_.config[i];
-
- HWPipeInfo &left_pipe = hw_layers_.config[i].left_pipe;
- HWPipeInfo &right_pipe = hw_layers_.config[i].right_pipe;
-
HWRotatorSession &hw_rotator_session = layer_config.hw_rotator_session;
- HWRotateInfo &left_rotate = hw_rotator_session.hw_rotate_info[0];
- HWRotateInfo &right_rotate = hw_rotator_session.hw_rotate_info[1];
- DumpImpl::AppendString(buffer, length, "\n\nsde idx: %u, actual idx: %u", i,
- hw_layers_.info.index[i]);
- DumpImpl::AppendString(buffer, length, "\nw: %u, h: %u, fmt: %u",
- input_buffer->width, input_buffer->height, input_buffer->format);
- AppendRect(buffer, length, "\nsrc_rect:", &layer.src_rect);
- AppendRect(buffer, length, "\ndst_rect:", &layer.dst_rect);
+ char idx[8] = { 0 };
+ const char *comp_type = GetName(layer.composition);
+ const char *buffer_format = GetName(input_buffer->format);
+ const char *rotate_split[2] = { "Rot-L", "Rot-R" };
+ const char *comp_split[2] = { "Comp-L", "Comp-R" };
- if (left_rotate.valid) {
- DumpImpl::AppendString(buffer, length, "\n\tleft rotate =>");
- DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", left_rotate.pipe_id);
- AppendRect(buffer, length, "\n\t src_roi:", &left_rotate.src_roi);
- AppendRect(buffer, length, "\n\t dst_roi:", &left_rotate.dst_roi);
+ snprintf(idx, sizeof(idx), "%d", layer_index);
+
+ for (uint32_t count = 0; count < hw_rotator_session.hw_block_count; count++) {
+ char writeback_id[8];
+ HWRotateInfo &rotate = hw_rotator_session.hw_rotate_info[count];
+ LayerRect &src_roi = rotate.src_roi;
+ LayerRect &dst_roi = rotate.dst_roi;
+
+ snprintf(writeback_id, sizeof(writeback_id), "%d", rotate.writeback_id);
+
+ DumpImpl::AppendString(buffer, length, format, idx, comp_type, rotate_split[count],
+ writeback_id, rotate.pipe_id, input_buffer->width,
+ input_buffer->height, buffer_format, INT(src_roi.left),
+ INT(src_roi.top), INT(src_roi.right), INT(src_roi.bottom),
+ INT(dst_roi.left), INT(dst_roi.top), INT(dst_roi.right),
+ INT(dst_roi.bottom), "-", "- ", "- ");
+
+ // print the below only once per layer block, fill with spaces for rest.
+ idx[0] = 0;
+ comp_type = "";
}
- if (right_rotate.valid) {
- DumpImpl::AppendString(buffer, length, "\n\tright rotate =>");
- DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", right_rotate.pipe_id);
- AppendRect(buffer, length, "\n\t src_roi:", &right_rotate.src_roi);
- AppendRect(buffer, length, "\n\t dst_roi:", &right_rotate.dst_roi);
+ if (hw_rotator_session.hw_block_count > 0) {
+ input_buffer = &hw_rotator_session.output_buffer;
+ buffer_format = GetName(input_buffer->format);
}
- if (left_pipe.valid) {
- DumpImpl::AppendString(buffer, length, "\n\tleft pipe =>");
- DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", left_pipe.pipe_id);
- AppendRect(buffer, length, "\n\t src_roi:", &left_pipe.src_roi);
- AppendRect(buffer, length, "\n\t dst_roi:", &left_pipe.dst_roi);
+ for (uint32_t count = 0; count < 2; count++) {
+ char decimation[16];
+ char flags[16];
+ char z_order[8];
+ HWPipeInfo &pipe = (count == 0) ? layer_config.left_pipe : layer_config.right_pipe;
+
+ if (!pipe.valid) {
+ continue;
+ }
+
+ LayerRect &src_roi = pipe.src_roi;
+ LayerRect &dst_roi = pipe.dst_roi;
+
+ snprintf(z_order, sizeof(z_order), "%d", pipe.z_order);
+ snprintf(flags, sizeof(flags), "0x%08x", layer.flags.flags);
+ snprintf(decimation, sizeof(decimation), "%3d x %3d", pipe.horizontal_decimation,
+ pipe.vertical_decimation);
+
+ DumpImpl::AppendString(buffer, length, format, idx, comp_type, comp_split[count],
+ "-", pipe.pipe_id, input_buffer->width, input_buffer->height,
+ buffer_format, INT(src_roi.left), INT(src_roi.top),
+ INT(src_roi.right), INT(src_roi.bottom), INT(dst_roi.left),
+ INT(dst_roi.top), INT(dst_roi.right), INT(dst_roi.bottom),
+ z_order, flags, decimation);
+
+ // print the below only once per layer block, fill with spaces for rest.
+ idx[0] = 0;
+ comp_type = "";
}
- if (right_pipe.valid) {
- DumpImpl::AppendString(buffer, length, "\n\tright pipe =>");
- DumpImpl::AppendString(buffer, length, "\n\t pipe id: 0x%x", right_pipe.pipe_id);
- AppendRect(buffer, length, "\n\t src_roi:", &right_pipe.src_roi);
- AppendRect(buffer, length, "\n\t dst_roi:", &right_pipe.dst_roi);
- }
+ DumpImpl::AppendString(buffer, length, newline);
}
}
-void DisplayBase::AppendRect(char *buffer, uint32_t length, const char *rect_name,
- LayerRect *rect) {
- DumpImpl::AppendString(buffer, length, "%s %.1f, %.1f, %.1f, %.1f",
- rect_name, rect->left, rect->top, rect->right, rect->bottom);
-}
-
int DisplayBase::GetBestConfig() {
return (num_modes_ == 1) ? 0 : -1;
}
@@ -497,5 +542,44 @@
return false;
}
-} // namespace sde
+const char * DisplayBase::GetName(const LayerComposition &composition) {
+ switch (composition) {
+ case kCompositionGPU: return "GPU";
+ case kCompositionSDE: return "SDE";
+ case kCompositionGPUTarget: return "GPU_TARGET";
+ default: return "UNKNOWN";
+ }
+}
+const char * DisplayBase::GetName(const LayerBufferFormat &format) {
+ switch (format) {
+ case kFormatARGB8888: return "ARGB_8888";
+ case kFormatRGBA8888: return "RGBA_8888";
+ case kFormatBGRA8888: return "BGRA_8888";
+ case kFormatXRGB8888: return "XRGB_8888";
+ case kFormatRGBX8888: return "RGBX_8888";
+ case kFormatBGRX8888: return "BGRX_8888";
+ case kFormatRGBA5551: return "RGBA_5551";
+ case kFormatRGBA4444: return "RGBA_4444";
+ case kFormatRGB888: return "RGB_888";
+ case kFormatBGR888: return "BGR_888";
+ case kFormatRGB565: return "RGB_565";
+ case kFormatRGBA8888Ubwc: return "RGBA_8888_UBWC";
+ case kFormatRGBX8888Ubwc: return "RGBX_8888_UBWC";
+ case kFormatRGB565Ubwc: return "RGB_565_UBWC";
+ case kFormatYCbCr420Planar: return "Y_CB_CR_420";
+ case kFormatYCrCb420Planar: return "Y_CR_CB_420";
+ case kFormatYCbCr420SemiPlanar: return "Y_CBCR_420";
+ case kFormatYCrCb420SemiPlanar: return "Y_CRCB_420";
+ case kFormatYCbCr420SemiPlanarVenus: return "Y_CBCR_420_VENUS";
+ case kFormatYCbCr422H1V2SemiPlanar: return "Y_CBCR_422_H1V2";
+ case kFormatYCrCb422H1V2SemiPlanar: return "Y_CRCB_422_H1V2";
+ case kFormatYCbCr422H2V1SemiPlanar: return "Y_CBCR_422_H2V1";
+ case kFormatYCrCb422H2V1SemiPlanar: return "Y_CRCB_422_H2V2";
+ case kFormatYCbCr420SPVenusUbwc: return "Y_CBCR_420_VENUS_UBWC";
+ case kFormatYCbCr422H2V1Packed: return "YCBYCR_422_H2V1";
+ default: return "UNKNOWN";
+ }
+}
+
+} // namespace sde
diff --git a/displayengine/libs/core/display_base.h b/displayengine/libs/core/display_base.h
index 1edef9e..0a33011 100644
--- a/displayengine/libs/core/display_base.h
+++ b/displayengine/libs/core/display_base.h
@@ -60,15 +60,14 @@
virtual DisplayError SetMaxMixerStages(uint32_t max_mixer_stages);
virtual DisplayError SetDisplayMode(uint32_t mode);
- private:
- bool IsRotationRequired(HWLayers *hw_layers);
-
protected:
// DumpImpl method
void AppendDump(char *buffer, uint32_t length);
- void AppendRect(char *buffer, uint32_t length, const char *rect_name, LayerRect *rect);
virtual int GetBestConfig();
+ bool IsRotationRequired(HWLayers *hw_layers);
+ const char * GetName(const LayerComposition &composition);
+ const char * GetName(const LayerBufferFormat &format);
DisplayType display_type_;
DisplayEventHandler *event_handler_;
diff --git a/displayengine/libs/core/display_hdmi.h b/displayengine/libs/core/display_hdmi.h
index 1a96884..ea1b80c 100644
--- a/displayengine/libs/core/display_hdmi.h
+++ b/displayengine/libs/core/display_hdmi.h
@@ -26,6 +26,7 @@
#define __DISPLAY_HDMI_H__
#include "display_base.h"
+#include "dump_impl.h"
namespace sde {
diff --git a/displayengine/libs/core/display_primary.cpp b/displayengine/libs/core/display_primary.cpp
index d6116fa..0fa5d2b 100644
--- a/displayengine/libs/core/display_primary.cpp
+++ b/displayengine/libs/core/display_primary.cpp
@@ -186,7 +186,7 @@
return kErrorNotSupported;
}
- switch(mode) {
+ switch (mode) {
case kModeVideo:
hw_display_mode = kModeVideo;
break;
diff --git a/displayengine/libs/core/display_primary.h b/displayengine/libs/core/display_primary.h
index be422de..1ed28b2 100644
--- a/displayengine/libs/core/display_primary.h
+++ b/displayengine/libs/core/display_primary.h
@@ -26,6 +26,7 @@
#define __DISPLAY_PRIMARY_H__
#include "display_base.h"
+#include "dump_impl.h"
namespace sde {
diff --git a/displayengine/libs/core/display_virtual.h b/displayengine/libs/core/display_virtual.h
index 8e7a764..f868612 100644
--- a/displayengine/libs/core/display_virtual.h
+++ b/displayengine/libs/core/display_virtual.h
@@ -26,6 +26,7 @@
#define __DISPLAY_VIRTUAL_H__
#include "display_base.h"
+#include "dump_impl.h"
namespace sde {
diff --git a/displayengine/libs/core/dump_impl.cpp b/displayengine/libs/core/dump_impl.cpp
index a5aca81..f9219f3 100755
--- a/displayengine/libs/core/dump_impl.cpp
+++ b/displayengine/libs/core/dump_impl.cpp
@@ -44,7 +44,7 @@
for (uint32_t i = 0; i < DumpImpl::dump_count_; i++) {
DumpImpl::dump_list_[i]->AppendDump(buffer, length);
}
- DumpImpl::AppendString(buffer, length, "\n-------------------------------------------\n");
+ DumpImpl::AppendString(buffer, length, "\n\n");
return kErrorNone;
}
diff --git a/displayengine/libs/core/fb/hw_device.cpp b/displayengine/libs/core/fb/hw_device.cpp
index 70d98de..d96820f 100644
--- a/displayengine/libs/core/fb/hw_device.cpp
+++ b/displayengine/libs/core/fb/hw_device.cpp
@@ -40,7 +40,6 @@
#include <utils/debug.h>
#include "hw_device.h"
-#include "scalar_helper.h"
#define __CLASS__ "HWDevice"
@@ -249,17 +248,15 @@
SetRect(pipe_info->dst_roi, &mdp_layer.dst_rect);
SetMDPFlags(layer, is_rotator_used, &mdp_layer.flags);
- mdp_scale_data* mdp_scale = GetScaleDataRef(mdp_layer_count);
-#ifdef USES_SCALAR
- // Set the configured scale data for MDP driver
- ScalarHelper::GetInstance()->SetScaleData(i, !count, mdp_scale);
- if (mdp_scale->enable_pxl_ext) {
- if ((mdp_layer.flags & MDP_LAYER_DEINTERLACE) && (layer.transform.rotation == 90.0f))
- ScalarHelper::GetInstance()->UpdateSrcWidth(i, !count, &mdp_buffer.width);
+ if (pipe_info->scale_data.enable_pixel_ext) {
+ if ((mdp_layer.flags & MDP_LAYER_DEINTERLACE) && (layer.transform.rotation == 90.0f)) {
+ mdp_buffer.width = pipe_info->scale_data.src_width;
+ }
+ SetHWScaleData(pipe_info->scale_data, mdp_layer_count);
}
-#endif
- mdp_layer.scale = mdp_scale;
+ // Send scale data to MDP driver
+ mdp_layer.scale = GetScaleDataRef(mdp_layer_count);
mdp_layer_count++;
DLOGV_IF(kTagDriverConfig, "******************* Layer[%d] %s pipe Input ******************",
@@ -274,7 +271,7 @@
mdp_layer.src_rect.y, mdp_layer.src_rect.w, mdp_layer.src_rect.h);
DLOGV_IF(kTagDriverConfig, "dst_rect [%d, %d, %d, %d]", mdp_layer.dst_rect.x,
mdp_layer.dst_rect.y, mdp_layer.dst_rect.w, mdp_layer.dst_rect.h);
- for (int j = 0; j < MAX_PLANES; j++) {
+ for (int j = 0; j < 4; j++) {
DLOGV_IF(kTagDriverConfig, "Scale Data[%d]: Phase=[%x %x %x %x] Pixel_Ext=[%d %d %d %d]",
j, mdp_layer.scale->init_phase_x[j], mdp_layer.scale->phase_step_x[j],
mdp_layer.scale->init_phase_y[j], mdp_layer.scale->phase_step_y[j],
@@ -318,9 +315,9 @@
return kErrorNone;
}
-void HWDevice::DumpLayerCommit(mdp_layer_commit &layer_commit) {
- mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
- mdp_input_layer *mdp_layers = mdp_commit.input_layers;
+void HWDevice::DumpLayerCommit(const mdp_layer_commit &layer_commit) {
+ const mdp_layer_commit_v1 &mdp_commit = layer_commit.commit_v1;
+ const mdp_input_layer *mdp_layers = mdp_commit.input_layers;
DLOGE("mdp_commit: flags = %x, release fence = %x", mdp_commit.flags, mdp_commit.release_fence);
DLOGE("left_roi: x = %d, y = %d, w = %d, h = %d", mdp_commit.left_roi.x, mdp_commit.left_roi.y,
@@ -330,10 +327,10 @@
for (uint32_t i = 0; i < mdp_commit.input_layer_cnt; i++) {
DLOGE("mdp_commit: layer_cnt = %d, pipe_ndx = %x, zorder = %d, flags = %x",
i, mdp_layers[i].pipe_ndx, mdp_layers[i].z_order, mdp_layers[i].flags);
- mdp_rect &src_rect = mdp_layers[i].src_rect;
+ const mdp_rect &src_rect = mdp_layers[i].src_rect;
DLOGE("src rect: x = %d, y = %d, w = %d, h = %d",
src_rect.x, src_rect.y, src_rect.w, src_rect.h);
- mdp_rect &dst_rect = mdp_layers[i].dst_rect;
+ const mdp_rect &dst_rect = mdp_layers[i].dst_rect;
DLOGE("dst rect: x = %d, y = %d, w = %d, h = %d",
dst_rect.x, dst_rect.y, dst_rect.w, dst_rect.h);
}
@@ -907,5 +904,36 @@
mdp_disp_commit_.commit_v1.retire_fence = -1;
}
+void HWDevice::SetHWScaleData(const ScaleData &scale, uint32_t index) {
+ mdp_scale_data *mdp_scale = GetScaleDataRef(index);
+ mdp_scale->enable_pxl_ext = scale.enable_pixel_ext;
+
+ for (int i = 0; i < 4; i++) {
+ const HWPlane &plane = scale.plane[i];
+ mdp_scale->init_phase_x[i] = plane.init_phase_x;
+ mdp_scale->phase_step_x[i] = plane.phase_step_x;
+ mdp_scale->init_phase_y[i] = plane.init_phase_y;
+ mdp_scale->phase_step_y[i] = plane.phase_step_y;
+
+ mdp_scale->num_ext_pxls_left[i] = plane.left.extension;
+ mdp_scale->left_ftch[i] = plane.left.overfetch;
+ mdp_scale->left_rpt[i] = plane.left.repeat;
+
+ mdp_scale->num_ext_pxls_top[i] = plane.top.extension;
+ mdp_scale->top_ftch[i] = plane.top.overfetch;
+ mdp_scale->top_rpt[i] = plane.top.repeat;
+
+ mdp_scale->num_ext_pxls_right[i] = plane.right.extension;
+ mdp_scale->right_ftch[i] = plane.right.overfetch;
+ mdp_scale->right_rpt[i] = plane.right.repeat;
+
+ mdp_scale->num_ext_pxls_btm[i] = plane.bottom.extension;
+ mdp_scale->btm_ftch[i] = plane.bottom.overfetch;
+ mdp_scale->btm_rpt[i] = plane.bottom.repeat;
+
+ mdp_scale->roi_w[i] = plane.roi_width;
+ }
+}
+
} // namespace sde
diff --git a/displayengine/libs/core/fb/hw_device.h b/displayengine/libs/core/fb/hw_device.h
index 917c884..18c6652 100644
--- a/displayengine/libs/core/fb/hw_device.h
+++ b/displayengine/libs/core/fb/hw_device.h
@@ -72,7 +72,7 @@
static const int kNumPhysicalDisplays = 2;
static const int kNumDisplayEvents = 4;
- void DumpLayerCommit(mdp_layer_commit &layer_commit);
+ void DumpLayerCommit(const mdp_layer_commit &layer_commit);
DisplayError SetFormat(const LayerBufferFormat &source, uint32_t *target);
DisplayError SetStride(HWDeviceType device_type, LayerBufferFormat format,
uint32_t width, uint32_t *target);
@@ -91,6 +91,7 @@
void GetSplitInfo(int device_node, HWPanelInfo *panel_info);
int ParseLine(char *input, char *tokens[], const uint32_t max_token, uint32_t *count);
mdp_scale_data* GetScaleDataRef(uint32_t index) { return &scale_data_[index]; }
+ void SetHWScaleData(const ScaleData &scale, uint32_t index);
void ResetDisplayParams();
bool EnableHotPlugDetection(int enable);
diff --git a/displayengine/libs/core/fb/hw_info.cpp b/displayengine/libs/core/fb/hw_info.cpp
index cddb590..7833c3c 100644
--- a/displayengine/libs/core/fb/hw_info.cpp
+++ b/displayengine/libs/core/fb/hw_info.cpp
@@ -123,6 +123,8 @@
hw_resource->max_bandwidth_high = atol(tokens[1]);
} else if (!strncmp(tokens[0], "max_mixer_width", strlen("max_mixer_width"))) {
hw_resource->max_mixer_width = atoi(tokens[1]);
+ } else if (!strncmp(tokens[0], "max_pipe_width", strlen("max_pipe_width"))) {
+ hw_resource->max_pipe_width = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "max_pipe_bw", strlen("max_pipe_bw"))) {
hw_resource->max_pipe_bw = atoi(tokens[1]);
} else if (!strncmp(tokens[0], "max_mdp_clk", strlen("max_mdp_clk"))) {
diff --git a/displayengine/libs/core/hw_interface.h b/displayengine/libs/core/hw_interface.h
index 36cb85e..5610ccd 100644
--- a/displayengine/libs/core/hw_interface.h
+++ b/displayengine/libs/core/hw_interface.h
@@ -102,12 +102,45 @@
HWRotatorSession() : hw_block_count(0), downscale_ratio(1.0f), session_id(-1) { }
};
+struct HWPixelExtension {
+ // Number of pixels extension in left, right, top and bottom directions for all color components.
+ // This pixel value for each color component should be sum of fetch and repeat pixels.
+ int extension;
+
+ // Number of pixels need to be overfetched in left, right, top and bottom directions from source
+ // image for scaling.
+ int overfetch;
+
+ // Number of pixels need to be repeated in left, right, top and bottom directions for scaling.
+ int repeat;
+};
+
+struct HWPlane {
+ int init_phase_x;
+ int phase_step_x;
+ int init_phase_y;
+ int phase_step_y;
+ HWPixelExtension left;
+ HWPixelExtension top;
+ HWPixelExtension right;
+ HWPixelExtension bottom;
+ uint32_t roi_width;
+};
+
+struct ScaleData {
+ uint8_t enable_pixel_ext;
+ uint32_t src_width;
+ uint32_t src_height;
+ HWPlane plane[4];
+};
+
struct HWPipeInfo {
uint32_t pipe_id;
LayerRect src_roi;
LayerRect dst_roi;
uint8_t horizontal_decimation;
uint8_t vertical_decimation;
+ ScaleData scale_data;
bool valid;
uint32_t z_order;
diff --git a/displayengine/libs/core/res_config.cpp b/displayengine/libs/core/res_config.cpp
index 29a92cf..c5a8a06 100644
--- a/displayengine/libs/core/res_config.cpp
+++ b/displayengine/libs/core/res_config.cpp
@@ -122,7 +122,7 @@
// For perf/power optimization, even if "always_src_split" is enabled, use 2 pipes only if:
// 1. Source width is greater than split_left (left_mixer_width)
// 2. Pipe clock exceeds the mixer clock
- if ((src_width > kMaxSourcePipeWidth) || (dst_width > kMaxSourcePipeWidth) ||
+ if ((src_width > hw_res_info_.max_pipe_width) || (dst_width > hw_res_info_.max_pipe_width) ||
(display_resource_ctx->display_attributes.always_src_split &&
((src_width > left_mixer_width) || (pipe_clock > mixer_clock)))) {
SplitRect(transform.flip_horizontal, src_rect, dst_rect, &left_pipe->src_roi,
@@ -169,7 +169,7 @@
crop_right_valid = CalculateCropRects(scissor, transform, &crop_right, &dst_right);
}
- if (crop_left_valid && (crop_left.right - crop_left.left) > kMaxSourcePipeWidth) {
+ if (crop_left_valid && (crop_left.right - crop_left.left) > hw_res_info_.max_pipe_width) {
if (crop_right_valid) {
DLOGV_IF(kTagResources, "Need more than 2 pipes: left width = %.0f, right width = %.0f",
crop_left.right - crop_left.left, crop_right.right - crop_right.left);
@@ -181,7 +181,8 @@
left_pipe->valid = true;
right_pipe->valid = true;
crop_right_valid = true;
- } else if (crop_right_valid && (crop_right.right - crop_right.left) > kMaxSourcePipeWidth) {
+ } else if (crop_right_valid &&
+ (crop_right.right - crop_right.left) > hw_res_info_.max_pipe_width) {
if (crop_left_valid) {
DLOGV_IF(kTagResources, "Need more than 2 pipes: left width = %.0f, right width = %.0f",
crop_left.right - crop_left.left, crop_right.right - crop_right.left);
@@ -234,12 +235,11 @@
for (uint32_t i = 0; i < layer_info.count; i++) {
Layer& layer = layer_info.stack->layers[layer_info.index[i]];
- float rot_scale = 1.0f;
- if (!IsValidDimension(layer)) {
- DLOGV_IF(kTagResources, "Input is invalid");
- Log(kTagResources, "input layer src_rect", layer.src_rect);
- Log(kTagResources, "input layer dst_rect", layer.dst_rect);
- return kErrorNotSupported;
+ float rotator_scale_factor = 1.0f;
+
+ error = ValidateLayerDimensions(layer);
+ if (error != kErrorNone) {
+ return error;
}
LayerRect scissor, src_rect, dst_rect;
@@ -253,7 +253,7 @@
HWPipeInfo &right_pipe = layer_config->right_pipe;
HWRotatorSession *hw_rotator_session = &layer_config->hw_rotator_session;
LayerTransform transform = layer.transform;
- bool rot90 = IsRotationNeeded(transform.rotation);
+ bool rotated90 = IsRotationNeeded(transform.rotation);
if (!CalculateCropRects(scissor, layer.transform, &src_rect, &dst_rect)) {
layer_config->Reset();
@@ -268,8 +268,19 @@
Normalize(align_x, align_y, &src_rect);
}
- if (ValidateScaling(layer, src_rect, dst_rect, &rot_scale)) {
- return kErrorNotSupported;
+ error = ValidateDimensions(src_rect, dst_rect, rotated90);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = ValidateScaling(src_rect, dst_rect, rotated90);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = GetRotatorScaleFactor(src_rect, dst_rect, rotated90, &rotator_scale_factor);
+ if (error != kErrorNone) {
+ return error;
}
// config rotator first
@@ -278,8 +289,8 @@
}
hw_rotator_session->hw_block_count = 0;
- if (rot90 || UINT32(rot_scale) != 1) {
- RotationConfig(layer, rot_scale, &src_rect, layer_config, rotate_count);
+ if (rotated90 || UINT32(rotator_scale_factor) != 1) {
+ RotationConfig(layer, rotator_scale_factor, &src_rect, layer_config, rotate_count);
// rotator will take care of flipping, reset tranform
transform = LayerTransform();
}
@@ -306,7 +317,7 @@
Log(kTagResources, "input layer src_rect", layer.src_rect);
Log(kTagResources, "input layer dst_rect", layer.dst_rect);
for (uint32_t k = 0; k < hw_rotator_session->hw_block_count; k++) {
- DLOGV_IF(kTagResources, "rotate num = %d, scale_x = %.2f", k, rot_scale);
+ DLOGV_IF(kTagResources, "rotate num = %d, scale_x = %.2f", k, rotator_scale_factor);
Log(kTagResources, "rotate src", hw_rotator_session->hw_rotate_info[k].src_roi);
Log(kTagResources, "rotate dst", hw_rotator_session->hw_rotate_info[k].dst_roi);
}
@@ -343,91 +354,6 @@
return error;
}
-DisplayError ResManager::ValidateScaling(const Layer &layer, const LayerRect &crop,
- const LayerRect &dst, float *rot_scale) {
- bool rotated90 = IsRotationNeeded(layer.transform.rotation) && (rot_scale != NULL);
- float crop_width = rotated90 ? crop.bottom - crop.top : crop.right - crop.left;
- float crop_height = rotated90 ? crop.right - crop.left : crop.bottom - crop.top;
- float dst_width = dst.right - dst.left;
- float dst_height = dst.bottom - dst.top;
-
- if ((dst_width < 1.0f) || (dst_height < 1.0f)) {
- DLOGV_IF(kTagResources, "dst ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
- dst_width, dst_height, dst.right, dst.bottom);
- return kErrorNotSupported;
- }
-
- if ((crop_width < 1.0f) || (crop_height < 1.0f)) {
- DLOGV_IF(kTagResources, "src ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
- crop_width, crop_height, crop.right, crop.bottom);
- return kErrorNotSupported;
- }
-
- if ((UINT32(crop_width - dst_width) == 1) || (UINT32(crop_height - dst_height) == 1)) {
- DLOGV_IF(kTagResources, "One pixel downscaling detected crop_w = %.0f, dst_w = %.0f, " \
- "crop_h = %.0f, dst_h = %.0f", crop_width, dst_width, crop_height, dst_height);
- return kErrorNotSupported;
- }
-
- float scale_x = crop_width / dst_width;
- float scale_y = crop_height / dst_height;
- uint32_t rot_scale_local = 1;
-
- if ((UINT32(scale_x) > 1) || (UINT32(scale_y) > 1)) {
- float max_scale_down = FLOAT(hw_res_info_.max_scale_down);
-
- if (hw_res_info_.has_rotator_downscale && !property_setting_.disable_rotator_downscaling &&
- rot_scale && !IsMacroTileFormat(layer.input_buffer)) {
- float scale_min = MIN(scale_x, scale_y);
- float scale_max = MAX(scale_x, scale_y);
- // use rotator to downscale when over the pipe scaling ability
- if (UINT32(scale_min) >= 2 && scale_max > max_scale_down) {
- // downscaling ratio needs be the same for both direction, use the smaller one.
- rot_scale_local = 1 << UINT32(ceilf(log2f(scale_min / max_scale_down)));
- if (rot_scale_local > kMaxRotateDownScaleRatio)
- rot_scale_local = kMaxRotateDownScaleRatio;
- scale_x /= FLOAT(rot_scale_local);
- scale_y /= FLOAT(rot_scale_local);
- }
- *rot_scale = FLOAT(rot_scale_local);
- }
-
- if (hw_res_info_.has_decimation && !property_setting_.disable_decimation &&
- !IsMacroTileFormat(layer.input_buffer)) {
- max_scale_down *= FLOAT(kMaxDecimationDownScaleRatio);
- }
-
- if (scale_x > max_scale_down || scale_y > max_scale_down) {
- DLOGV_IF(kTagResources,
- "Scaling down is over the limit: is_tile = %d, scale_x = %.0f, scale_y = %.0f, " \
- "crop_w = %.0f, dst_w = %.0f, has_deci = %d, disable_deci = %d, rot_scale = %d",
- IsMacroTileFormat(layer.input_buffer), scale_x, scale_y, crop_width, dst_width,
- hw_res_info_.has_decimation, property_setting_.disable_decimation, rot_scale_local);
- return kErrorNotSupported;
- }
- }
-
- float max_scale_up = FLOAT(hw_res_info_.max_scale_up);
- if (UINT32(scale_x) < 1 && scale_x > 0.0f) {
- if ((1.0f / scale_x) > max_scale_up) {
- DLOGV_IF(kTagResources, "Scaling up is over limit scale_x = %f", 1.0f / scale_x);
- return kErrorNotSupported;
- }
- }
-
- if (UINT32(scale_y) < 1 && scale_y > 0.0f) {
- if ((1.0f / scale_y) > max_scale_up) {
- DLOGV_IF(kTagResources, "Scaling up is over limit scale_y = %f", 1.0f / scale_y);
- return kErrorNotSupported;
- }
- }
-
- DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f, rot_scale = %d",
- scale_x, scale_y, rot_scale_local);
-
- return kErrorNone;
-}
-
void ResManager::CalculateCut(const LayerTransform &transform, float *left_cut_ratio,
float *top_cut_ratio, float *right_cut_ratio,
float *bottom_cut_ratio) {
@@ -514,7 +440,7 @@
return false;
}
-bool ResManager::IsValidDimension(const Layer &layer) {
+DisplayError ResManager::ValidateLayerDimensions(const Layer &layer) {
const LayerRect &src = layer.src_rect;
const LayerRect &dst = layer.dst_rect;
LayerBuffer *input_buffer = layer.input_buffer;
@@ -522,17 +448,231 @@
if (!IsValid(src) || !IsValid(dst)) {
Log(kTagResources, "input layer src_rect", src);
Log(kTagResources, "input layer dst_rect", dst);
- return false;
+ return kErrorNotSupported;
}
// Make sure source in integral only if it is a non secure layer.
if (!input_buffer->flags.secure && (src.left - roundf(src.left) || src.top - roundf(src.top) ||
src.right - roundf(src.right) || src.bottom - roundf(src.bottom))) {
DLOGV_IF(kTagResources, "Input ROI is not integral");
- return false;
+ return kErrorNotSupported;
}
- return true;
+ return kErrorNone;
+}
+
+DisplayError ResManager::ValidateDimensions(const LayerRect &crop, const LayerRect &dst,
+ bool rotated90) {
+ float crop_width = 0.0f, crop_height = 0.0f, dst_width = 0.0f, dst_height = 0.0f;
+
+ DisplayError error = GetCropAndDestination(crop, dst, rotated90, &crop_width, &crop_height,
+ &dst_width, &dst_height);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ if ((dst_width < 1.0f) || (dst_height < 1.0f)) {
+ DLOGV_IF(kTagResources, "dst ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
+ dst_width, dst_height, dst.right, dst.bottom);
+ return kErrorNotSupported;
+ }
+
+ if ((crop_width < 1.0f) || (crop_height < 1.0f)) {
+ DLOGV_IF(kTagResources, "src ROI is too small w = %.0f, h = %.0f, right = %.0f, bottom = %.0f",
+ crop_width, crop_height, crop.right, crop.bottom);
+ return kErrorNotSupported;
+ }
+
+ if ((UINT32(crop_width - dst_width) == 1) || (UINT32(crop_height - dst_height) == 1)) {
+ DLOGV_IF(kTagResources, "One pixel downscaling detected crop_w = %.0f, dst_w = %.0f, " \
+ "crop_h = %.0f, dst_h = %.0f", crop_width, dst_width, crop_height, dst_height);
+ return kErrorNotSupported;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError ResManager::ValidatePipeParams(HWPipeInfo *pipe_info) {
+ DisplayError error = kErrorNone;
+
+ const LayerRect &src_rect = pipe_info->src_roi;
+ const LayerRect &dst_rect = pipe_info->dst_roi;
+
+ error = ValidateDimensions(src_rect, dst_rect, false /* rotated90 */);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = ValidateScaling(src_rect, dst_rect, false /* rotated90 */);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError ResManager::ValidateScaling(const LayerRect &crop, const LayerRect &dst,
+ bool rotated90) {
+ DisplayError error = kErrorNone;
+
+ float scale_x = 1.0f;
+ float scale_y = 1.0f;
+
+ error = GetScaleFactor(crop, dst, rotated90, &scale_x, &scale_y);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = ValidateDownScaling(scale_x, scale_y);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ error = ValidateUpScaling(scale_x, scale_y);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ return kErrorNone;
+}
+
+DisplayError ResManager::ValidateDownScaling(float scale_x, float scale_y) {
+ if ((UINT32(scale_x) > 1) || (UINT32(scale_y) > 1)) {
+ float max_scale_down = FLOAT(hw_res_info_.max_scale_down);
+ float rotator_scale_factor = 1.0f;
+
+ if (hw_res_info_.has_rotator_downscale && !property_setting_.disable_rotator_downscaling) {
+ rotator_scale_factor = GetRotatorScaleFactor(scale_x, scale_y);
+ scale_x /= rotator_scale_factor;
+ scale_y /= rotator_scale_factor;
+
+ DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f, rotator_scale_factor = %d",
+ scale_x, scale_y, rotator_scale_factor);
+ }
+
+ if (hw_res_info_.has_decimation && !property_setting_.disable_decimation) {
+ max_scale_down *= FLOAT(kMaxDecimationDownScaleRatio);
+ }
+
+ if (scale_x > max_scale_down || scale_y > max_scale_down) {
+ DLOGV_IF(kTagResources,
+ "Scaling down is over the limit: scale_x = %.0f, scale_y = %.0f, " \
+ "has_deci = %d, disable_deci = %d, rotator_scale_factor= %.0f",
+ scale_x, scale_y, hw_res_info_.has_decimation, property_setting_.disable_decimation,
+ rotator_scale_factor);
+ return kErrorNotSupported;
+ }
+ }
+
+ DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f", scale_x, scale_y);
+
+ return kErrorNone;
+}
+
+DisplayError ResManager::ValidateUpScaling(float scale_x, float scale_y) {
+ float max_scale_up = FLOAT(hw_res_info_.max_scale_up);
+
+ if (UINT32(scale_x) < 1 && scale_x > 0.0f) {
+ if ((1.0f / scale_x) > max_scale_up) {
+ DLOGV_IF(kTagResources, "Scaling up is over limit scale_x = %f", 1.0f / scale_x);
+ return kErrorNotSupported;
+ }
+ }
+
+ if (UINT32(scale_y) < 1 && scale_y > 0.0f) {
+ if ((1.0f / scale_y) > max_scale_up) {
+ DLOGV_IF(kTagResources, "Scaling up is over limit scale_y = %f", 1.0f / scale_y);
+ return kErrorNotSupported;
+ }
+ }
+
+ DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f", scale_x, scale_y);
+
+ return kErrorNone;
+}
+
+DisplayError ResManager::GetCropAndDestination(const LayerRect &crop, const LayerRect &dst,
+ const bool rotated90, float *crop_width,
+ float *crop_height, float *dst_width,
+ float *dst_height) {
+ if (!IsValid(crop)) {
+ Log(kTagResources, "Invalid crop rect", crop);
+ return kErrorNotSupported;
+ }
+
+ if (!IsValid(dst)) {
+ Log(kTagResources, "Invalid dst rect", dst);
+ return kErrorNotSupported;
+ }
+
+ *crop_width = crop.right - crop.left;
+ *crop_height = crop.bottom - crop.top;
+ if (rotated90) {
+ Swap(*crop_width, *crop_height);
+ }
+
+ *dst_width = dst.right - dst.left;
+ *dst_height = dst.bottom - dst.top;
+
+ return kErrorNone;
+}
+
+DisplayError ResManager::GetRotatorScaleFactor(const LayerRect &crop, const LayerRect &dst,
+ bool rotated90, float *rotator_scale_factor) {
+ DisplayError error = kErrorNone;
+
+ float scale_x = 1.0f;
+ float scale_y = 1.0f;
+
+ if (hw_res_info_.has_rotator_downscale && !property_setting_.disable_rotator_downscaling) {
+ error = GetScaleFactor(crop, dst, rotated90, &scale_x, &scale_y);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ *rotator_scale_factor = GetRotatorScaleFactor(scale_x, scale_y);
+ } else {
+ *rotator_scale_factor = 1.0f;
+ }
+
+ return kErrorNone;
+}
+
+float ResManager::GetRotatorScaleFactor(float scale_x, float scale_y) {
+ float max_scale_down = FLOAT(hw_res_info_.max_scale_down);
+ float scale_min = MIN(scale_x, scale_y);
+ float scale_max = MAX(scale_x, scale_y);
+ uint32_t rotator_scale_factor = 1;
+
+ // use rotator to downscale when over the pipe scaling ability
+ if (UINT32(scale_min) >= 2 && scale_max > max_scale_down) {
+ // downscaling ratio needs be the same for both direction, use the smaller one.
+ rotator_scale_factor = 1 << UINT32(ceilf(log2f(scale_min / max_scale_down)));
+ if (rotator_scale_factor > kMaxRotateDownScaleRatio) {
+ rotator_scale_factor = kMaxRotateDownScaleRatio;
+ }
+ }
+
+ DLOGV_IF(kTagResources, "scale_x = %.4f, scale_y = %.4f, rotator_scale_factor = %d",
+ scale_x, scale_y, rotator_scale_factor);
+
+ return FLOAT(rotator_scale_factor);
+}
+
+DisplayError ResManager::GetScaleFactor(const LayerRect &crop, const LayerRect &dst,
+ bool rotated90, float *scale_x, float *scale_y) {
+ float crop_width = 1.0f, crop_height = 1.0f, dst_width = 1.0f, dst_height = 1.0f;
+
+ DisplayError error = GetCropAndDestination(crop, dst, rotated90, &crop_width, &crop_height,
+ &dst_width, &dst_height);
+ if (error != kErrorNone) {
+ return error;
+ }
+
+ *scale_x = crop_width / dst_width;
+ *scale_y = crop_height / dst_height;
+
+ return kErrorNone;
}
DisplayError ResManager::SetDecimationFactor(HWPipeInfo *pipe) {
@@ -631,13 +771,14 @@
}
right_pipe->dst_roi.left = left_pipe->dst_roi.right;
}
- error = ValidateScaling(layer, left_pipe->src_roi, left_pipe->dst_roi, NULL);
+
+ error = ValidatePipeParams(left_pipe);
if (error != kErrorNone) {
goto PipeConfigExit;
}
if (right_pipe->valid) {
- error = ValidateScaling(layer, right_pipe->src_roi, right_pipe->dst_roi, NULL);
+ error = ValidatePipeParams(right_pipe);
}
PipeConfigExit:
if (error != kErrorNone) {
diff --git a/displayengine/libs/core/res_manager.cpp b/displayengine/libs/core/res_manager.cpp
index 06f6b4d..2bd1edf 100644
--- a/displayengine/libs/core/res_manager.cpp
+++ b/displayengine/libs/core/res_manager.cpp
@@ -28,7 +28,6 @@
#include <dlfcn.h>
#include "res_manager.h"
-#include "scalar_helper.h"
#define __CLASS__ "ResManager"
@@ -36,24 +35,22 @@
ResManager::ResManager()
: num_pipe_(0), vig_pipes_(NULL), rgb_pipes_(NULL), dma_pipes_(NULL), virtual_count_(0),
- buffer_allocator_(NULL), buffer_sync_handler_(NULL) {
+ buffer_allocator_(NULL), buffer_sync_handler_(NULL), scalar_(NULL) {
}
DisplayError ResManager::Init(const HWResourceInfo &hw_res_info) {
- hw_res_info_ = hw_res_info;
-
- if (!hw_res_info_.max_mixer_width)
- hw_res_info_.max_mixer_width = kMaxSourcePipeWidth;
-
DisplayError error = kErrorNone;
+ uint32_t num_pipe = 0;
- num_pipe_ = hw_res_info_.num_vig_pipe + hw_res_info_.num_rgb_pipe + hw_res_info_.num_dma_pipe;
+ num_pipe = hw_res_info.num_vig_pipe + hw_res_info.num_rgb_pipe + hw_res_info.num_dma_pipe;
- if (num_pipe_ > kPipeIdMax) {
- DLOGE("Number of pipe is over the limit! %d", num_pipe_);
+ if (num_pipe > kPipeIdMax) {
+ DLOGE("Number of pipe is over the limit! %d", num_pipe);
return kErrorParameters;
}
+ num_pipe_ = num_pipe;
+ hw_res_info_ = hw_res_info;
// Init pipe info
vig_pipes_ = &src_pipes_[0];
rgb_pipes_ = &src_pipes_[hw_res_info_.num_vig_pipe];
@@ -112,18 +109,17 @@
rgb_pipes_[0].state = kPipeStateOwnedByKernel;
rgb_pipes_[1].state = kPipeStateOwnedByKernel;
-#ifdef USES_SCALAR
- ScalarHelper::GetInstance()->Init();
-#endif
+ error = Scalar::CreateScalar(&scalar_);
+ if (error != kErrorNone) {
+ DLOGE("Failed to create Scalar object!");
+ }
max_system_bw_ = FLOAT(hw_res_info_.max_bandwidth_high);
- return kErrorNone;
+ return error;
}
DisplayError ResManager::Deinit() {
-#ifdef USES_SCALAR
- ScalarHelper::GetInstance()->Deinit();
-#endif
+ Scalar::Destroy(scalar_);
return kErrorNone;
}
@@ -381,12 +377,10 @@
i, layer_config.left_pipe.pipe_id, pipe_info->pipe_id);
}
-#ifdef USES_SCALAR
- if (!ScalarHelper::GetInstance()->ConfigureScale(hw_layers)) {
+ if (scalar_->ConfigureScale(hw_layers) != kErrorNone) {
DLOGV_IF(kTagResources, "Scale data configuration has failed!");
goto CleanupOnError;
}
-#endif
if (!CheckBandwidth(display_resource_ctx, hw_layers)) {
DLOGV_IF(kTagResources, "Bandwidth check failed!");
diff --git a/displayengine/libs/core/res_manager.h b/displayengine/libs/core/res_manager.h
index bd33fec..32eb6ea 100644
--- a/displayengine/libs/core/res_manager.h
+++ b/displayengine/libs/core/res_manager.h
@@ -31,6 +31,7 @@
#include "hw_interface.h"
#include "dump_impl.h"
+#include "scalar_helper.h"
namespace sde {
@@ -49,6 +50,7 @@
DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
void Purge(Handle display_ctx);
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);
@@ -85,7 +87,6 @@
// todo: retrieve all these from kernel
enum {
- kMaxSourcePipeWidth = 2048,
kMaxInterfaceWidth = 2048,
kMaxRotateDownScaleRatio = 8,
kMaxDecimationDownScaleRatio = 8,
@@ -164,8 +165,6 @@
const LayerTransform &transform, const LayerRect &src_rect,
const LayerRect &dst_rect, 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,
@@ -174,7 +173,19 @@
float *right_cut_ratio, float *bottom_cut_ratio);
bool CalculateCropRects(const LayerRect &scissor, const LayerTransform &transform,
LayerRect *crop, LayerRect *dst);
- bool IsValidDimension(const Layer &layer);
+ DisplayError ValidateLayerDimensions(const Layer &layer);
+ DisplayError ValidateDimensions(const LayerRect &crop, const LayerRect &dst, bool rotate90);
+ DisplayError ValidatePipeParams(HWPipeInfo *pipe_info);
+ DisplayError ValidateDownScaling(float scale_x, float scale_y);
+ DisplayError ValidateUpScaling(float scale_x, float scale_y);
+ DisplayError GetCropAndDestination(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90, float *crop_width, float *crop_height,
+ float *dst_width, float *dst_height);
+ DisplayError GetRotatorScaleFactor(const LayerRect &crop, const LayerRect &dst,
+ bool rotate90, float *rotator_scale_factor);
+ float GetRotatorScaleFactor(float scale_x, float scale_y);
+ DisplayError GetScaleFactor(const LayerRect &crop, const LayerRect &dst, bool rotate90,
+ float *scale_x, float *scale_y);
bool CheckBandwidth(DisplayResourceContext *display_ctx, HWLayers *hw_layers);
float GetPipeBw(DisplayResourceContext *display_ctx, HWPipeInfo *pipe, float bpp);
float GetClockForPipe(DisplayResourceContext *display_ctx, HWPipeInfo *pipe);
@@ -200,7 +211,7 @@
HWPipeInfo *left_pipe, HWPipeInfo *right_pipe,
uint32_t align_x, uint32_t align_y);
void ResourceStateLog(void);
- DisplayError CalculateDecimation(float downscale, uint8_t* decimation);
+ DisplayError CalculateDecimation(float downscale, uint8_t *decimation);
Locker locker_;
HWResourceInfo hw_res_info_;
@@ -221,6 +232,7 @@
BufferSyncHandler *buffer_sync_handler_; // Pointer to buffer sync handler that was defined by
// the display engine's client
PropertySetting property_setting_;
+ Scalar *scalar_;
};
} // namespace sde
diff --git a/displayengine/libs/core/rotator_ctrl.cpp b/displayengine/libs/core/rotator_ctrl.cpp
index 701006c..8018e31 100644
--- a/displayengine/libs/core/rotator_ctrl.cpp
+++ b/displayengine/libs/core/rotator_ctrl.cpp
@@ -84,7 +84,7 @@
}
DisplayError RotatorCtrl::RegisterDisplay(DisplayType type, Handle *display_ctx) {
- DisplaRotatorContext *disp_rotator_ctx = new DisplaRotatorContext();
+ DisplayRotatorContext *disp_rotator_ctx = new DisplayRotatorContext();
if (disp_rotator_ctx == NULL) {
return kErrorMemory;
}
@@ -96,7 +96,7 @@
}
void RotatorCtrl::UnregisterDisplay(Handle display_ctx) {
- DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+ DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
delete disp_rotator_ctx;
disp_rotator_ctx = NULL;
@@ -106,9 +106,9 @@
DisplayError RotatorCtrl::Prepare(Handle display_ctx, HWLayers *hw_layers) {
DisplayError error = kErrorNone;
- DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+ DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
- error = PrepareSessions(hw_layers);
+ error = PrepareSessions(disp_rotator_ctx, hw_layers);
if (error != kErrorNone) {
DLOGE("Prepare rotator session failed for display %d", disp_rotator_ctx->display_type);
return error;
@@ -126,9 +126,9 @@
DisplayError RotatorCtrl::Commit(Handle display_ctx, HWLayers *hw_layers) {
DisplayError error = kErrorNone;
- DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+ DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
- error = GetOutputBuffers(hw_layers);
+ error = GetOutputBuffers(disp_rotator_ctx, hw_layers);
if (error != kErrorNone) {
return error;
}
@@ -145,7 +145,8 @@
DisplayError RotatorCtrl::PostCommit(Handle display_ctx, HWLayers *hw_layers) {
HWLayersInfo &hw_layer_info = hw_layers->info;
DisplayError error = kErrorNone;
- DisplaRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplaRotatorContext *>(display_ctx);
+ DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+ int client_id = INT(disp_rotator_ctx->display_type);
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
@@ -155,7 +156,7 @@
continue;
}
- error = session_manager_->SetReleaseFd(hw_rotator_session);
+ error = session_manager_->SetReleaseFd(client_id, hw_rotator_session);
if (error != kErrorNone) {
DLOGE("Rotator Post commit failed for display %d", disp_rotator_ctx->display_type);
return error;
@@ -165,11 +166,22 @@
return kErrorNone;
}
-DisplayError RotatorCtrl::PrepareSessions(HWLayers *hw_layers) {
+DisplayError RotatorCtrl::Purge(Handle display_ctx, HWLayers *hw_layers) {
+ DisplayRotatorContext *disp_rotator_ctx = reinterpret_cast<DisplayRotatorContext *>(display_ctx);
+ int client_id = INT(disp_rotator_ctx->display_type);
+
+ session_manager_->Start(client_id);
+
+ return session_manager_->Stop(client_id);
+}
+
+DisplayError RotatorCtrl::PrepareSessions(DisplayRotatorContext *disp_rotator_ctx,
+ HWLayers *hw_layers) {
HWLayersInfo &hw_layer_info = hw_layers->info;
DisplayError error = kErrorNone;
+ int client_id = INT(disp_rotator_ctx->display_type);
- session_manager_->Start();
+ session_manager_->Start(client_id);
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
@@ -197,20 +209,25 @@
hw_session_config.secure = layer.input_buffer->flags.secure;
hw_session_config.frame_rate = layer.frame_rate;
- error = session_manager_->OpenSession(hw_rotator_session);
+ error = session_manager_->OpenSession(client_id, hw_rotator_session);
if (error != kErrorNone) {
return error;
}
}
- session_manager_->Stop();
+ error = session_manager_->Stop(client_id);
+ if (error != kErrorNone) {
+ return error;
+ }
return kErrorNone;
}
-DisplayError RotatorCtrl::GetOutputBuffers(HWLayers *hw_layers) {
+DisplayError RotatorCtrl::GetOutputBuffers(DisplayRotatorContext *disp_rotator_ctx,
+ HWLayers *hw_layers) {
HWLayersInfo &hw_layer_info = hw_layers->info;
DisplayError error = kErrorNone;
+ int client_id = INT(disp_rotator_ctx->display_type);
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer& layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
@@ -220,7 +237,7 @@
continue;
}
- error = session_manager_->GetNextBuffer(hw_rotator_session);
+ error = session_manager_->GetNextBuffer(client_id, hw_rotator_session);
if (error != kErrorNone) {
return error;
}
diff --git a/displayengine/libs/core/rotator_ctrl.h b/displayengine/libs/core/rotator_ctrl.h
index 083f4ca..3e5deaf 100644
--- a/displayengine/libs/core/rotator_ctrl.h
+++ b/displayengine/libs/core/rotator_ctrl.h
@@ -47,6 +47,7 @@
DisplayError Prepare(Handle display_ctx, HWLayers *hw_layers);
DisplayError Commit(Handle display_ctx, HWLayers *hw_layers);
DisplayError PostCommit(Handle display_ctx, HWLayers *hw_layers);
+ DisplayError Purge(Handle display_ctx, HWLayers *hw_layers);
private:
enum {
@@ -55,14 +56,14 @@
kTripleBuffering = 3,
};
- struct DisplaRotatorContext {
+ struct DisplayRotatorContext {
DisplayType display_type;
- DisplaRotatorContext() : display_type(kPrimary) { }
+ DisplayRotatorContext() : display_type(kPrimary) { }
};
- DisplayError PrepareSessions(HWLayers *hw_layers);
- DisplayError GetOutputBuffers(HWLayers *hw_layers);
+ DisplayError PrepareSessions(DisplayRotatorContext *disp_rotator_ctx, HWLayers *hw_layers);
+ DisplayError GetOutputBuffers(DisplayRotatorContext *disp_rotator_ctx, HWLayers *hw_layers);
HWRotatorInterface *hw_rotator_intf_;
SessionManager *session_manager_;
diff --git a/displayengine/libs/core/scalar_helper.cpp b/displayengine/libs/core/scalar_helper.cpp
index b5d8989..e600b79 100644
--- a/displayengine/libs/core/scalar_helper.cpp
+++ b/displayengine/libs/core/scalar_helper.cpp
@@ -22,8 +22,6 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifdef USES_SCALAR
-
#include <dlfcn.h>
#include <utils/debug.h>
#include "scalar_helper.h"
@@ -32,40 +30,94 @@
namespace sde {
-ScalarHelper* ScalarHelper::scalar_helper_ = NULL;
+#ifdef USES_SCALAR
+ScalarHelper::ScalarHelper()
+ : scalar_library_name_("libscalar.so"), configure_scale_api_("configureScale"),
+ lib_scalar_(NULL), configure_scale_(NULL) {
+}
-ScalarHelper* ScalarHelper::GetInstance() {
- if (scalar_helper_ == NULL) {
- scalar_helper_ = new ScalarHelper();
+DisplayError ScalarHelper::Init() {
+ lib_scalar_ = dlopen(scalar_library_name_, RTLD_NOW);
+ if (lib_scalar_) {
+ void **scalar_func = reinterpret_cast<void **>(&configure_scale_);
+ *scalar_func = ::dlsym(lib_scalar_, configure_scale_api_);
+ if (!configure_scale_) {
+ DLOGE("Unable to find symbol for %s API!", configure_scale_api_);
+ dlclose(lib_scalar_);
+ return kErrorUndefined;
+ }
+ } else {
+ DLOGW("Unable to load %s !", scalar_library_name_);
+ return kErrorNotSupported;
}
- return scalar_helper_;
+
+ return kErrorNone;
}
-// Scalar helper functions
-static void SetPipeInfo(HWPipeInfo* hw_pipe, scalar::PipeInfo* pipe) {
- pipe->id = hw_pipe->pipe_id;
- pipe->horz_deci = hw_pipe->horizontal_decimation;
- pipe->vert_deci = hw_pipe->vertical_decimation;
-
- pipe->src_rect.x = UINT32(hw_pipe->src_roi.left);
- pipe->src_rect.y = UINT32(hw_pipe->src_roi.top);
- pipe->src_rect.w = UINT32(hw_pipe->src_roi.right) - pipe->src_rect.x;
- pipe->src_rect.h = UINT32(hw_pipe->src_roi.bottom) - pipe->src_rect.y;
-
- pipe->dst_rect.x = UINT32(hw_pipe->dst_roi.left);
- pipe->dst_rect.y = UINT32(hw_pipe->dst_roi.top);
- pipe->dst_rect.w = UINT32(hw_pipe->dst_roi.right) - pipe->dst_rect.x;
- pipe->dst_rect.h = UINT32(hw_pipe->dst_roi.bottom) - pipe->dst_rect.y;
+void ScalarHelper::Deinit() {
+ if (lib_scalar_) {
+ dlclose(lib_scalar_);
+ }
}
-static void UpdateSrcRoi(scalar::PipeInfo* pipe, HWPipeInfo* hw_pipe) {
- hw_pipe->src_roi.left = FLOAT(pipe->src_rect.x);
- hw_pipe->src_roi.top = FLOAT(pipe->src_rect.y);
- hw_pipe->src_roi.right = FLOAT(pipe->src_rect.x + pipe->src_rect.w);
- hw_pipe->src_roi.bottom = FLOAT(pipe->src_rect.y + pipe->src_rect.h);
+// Helper functions
+void ScalarHelper::SetPipeInfo(const HWPipeInfo &hw_pipe, scalar::PipeInfo *pipe) {
+ pipe->id = hw_pipe.pipe_id;
+ pipe->horz_deci = hw_pipe.horizontal_decimation;
+ pipe->vert_deci = hw_pipe.vertical_decimation;
+
+ pipe->src_rect.x = UINT32(hw_pipe.src_roi.left);
+ pipe->src_rect.y = UINT32(hw_pipe.src_roi.top);
+ pipe->src_rect.w = UINT32(hw_pipe.src_roi.right) - pipe->src_rect.x;
+ pipe->src_rect.h = UINT32(hw_pipe.src_roi.bottom) - pipe->src_rect.y;
+
+ pipe->dst_rect.x = UINT32(hw_pipe.dst_roi.left);
+ pipe->dst_rect.y = UINT32(hw_pipe.dst_roi.top);
+ pipe->dst_rect.w = UINT32(hw_pipe.dst_roi.right) - pipe->dst_rect.x;
+ pipe->dst_rect.h = UINT32(hw_pipe.dst_roi.bottom) - pipe->dst_rect.y;
}
-static uint32_t GetScalarFormat(LayerBufferFormat source) {
+void ScalarHelper::UpdateSrcRoi(const scalar::PipeInfo &pipe, HWPipeInfo *hw_pipe) {
+ hw_pipe->src_roi.left = FLOAT(pipe.src_rect.x);
+ hw_pipe->src_roi.top = FLOAT(pipe.src_rect.y);
+ hw_pipe->src_roi.right = FLOAT(pipe.src_rect.x + pipe.src_rect.w);
+ hw_pipe->src_roi.bottom = FLOAT(pipe.src_rect.y + pipe.src_rect.h);
+}
+
+void ScalarHelper::SetScaleData(const scalar::PipeInfo &pipe, ScaleData *scale_data) {
+ scalar::Scale *scale = pipe.scale_data;
+ scale_data->src_width = pipe.src_width;
+ scale_data->src_height = pipe.src_height;
+ scale_data->enable_pixel_ext = scale->enable_pxl_ext;
+
+ for (int i = 0; i < 4; i++) {
+ HWPlane &plane = scale_data->plane[i];
+ plane.init_phase_x = scale->init_phase_x[i];
+ plane.phase_step_x = scale->phase_step_x[i];
+ plane.init_phase_y = scale->init_phase_y[i];
+ plane.phase_step_y = scale->phase_step_y[i];
+
+ plane.left.extension = scale->left.extension[i];
+ plane.left.overfetch = scale->left.overfetch[i];
+ plane.left.repeat = scale->left.repeat[i];
+
+ plane.top.extension = scale->top.extension[i];
+ plane.top.overfetch = scale->top.overfetch[i];
+ plane.top.repeat = scale->top.repeat[i];
+
+ plane.right.extension = scale->right.extension[i];
+ plane.right.overfetch = scale->right.overfetch[i];
+ plane.right.repeat = scale->right.repeat[i];
+
+ plane.bottom.extension = scale->bottom.extension[i];
+ plane.bottom.overfetch = scale->bottom.overfetch[i];
+ plane.bottom.repeat = scale->bottom.repeat[i];
+
+ plane.roi_width = scale->roi_width[i];
+ }
+}
+
+uint32_t ScalarHelper::GetScalarFormat(LayerBufferFormat source) {
uint32_t format = scalar::UNKNOWN_FORMAT;
switch (source) {
@@ -101,48 +153,26 @@
return format;
}
-void ScalarHelper::Init() {
- lib_scalar_handle_ = NULL;
- ScalarConfigureScale = NULL;
-
- lib_scalar_handle_ = dlopen(SCALAR_LIBRARY_NAME, RTLD_NOW);
- if (lib_scalar_handle_) {
- void **scalar_func = reinterpret_cast<void **>(&ScalarConfigureScale);
- *scalar_func = ::dlsym(lib_scalar_handle_, "configureScale");
- } else {
- DLOGW("Unable to load %s !", SCALAR_LIBRARY_NAME);
- }
-}
-
-void ScalarHelper::Deinit() {
- if (lib_scalar_handle_) {
- dlclose(lib_scalar_handle_);
- lib_scalar_handle_ = NULL;
- }
-}
-
-bool ScalarHelper::ConfigureScale(HWLayers *hw_layers) {
-
- if (!lib_scalar_handle_ || !ScalarConfigureScale) {
- // No scalar library
- return true;
- }
-
- // Reset scale data
- memset(&scale_data_, 0, sizeof(scale_data_));
+DisplayError ScalarHelper::ConfigureScale(HWLayers *hw_layers) {
HWLayersInfo &hw_layer_info = hw_layers->info;
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
Layer &layer = hw_layer_info.stack->layers[hw_layer_info.index[i]];
uint32_t width = layer.input_buffer->width;
+ uint32_t height = layer.input_buffer->height;
LayerBufferFormat format = layer.input_buffer->format;
- HWPipeInfo* left_pipe = &hw_layers->config[i].left_pipe;
- HWPipeInfo* right_pipe = &hw_layers->config[i].right_pipe;
+ HWPipeInfo &left_pipe = hw_layers->config[i].left_pipe;
+ HWPipeInfo &right_pipe = hw_layers->config[i].right_pipe;
HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
+ // Reset scale data
+ memset(&left_pipe.scale_data, 0, sizeof(ScaleData));
+ memset(&right_pipe.scale_data, 0, sizeof(ScaleData));
+
// Prepare data structure for lib scalar
uint32_t flags = 0;
struct scalar::LayerInfo layer_info;
+ struct scalar::Scale left_scale, right_scale;
if (layer.transform.rotation == 90.0f) {
// Flips will be taken care by rotator, if layer requires 90 rotation
@@ -153,18 +183,20 @@
}
for (uint32_t count = 0; count < 2; count++) {
- HWPipeInfo* hw_pipe = (count == 0) ? left_pipe : right_pipe;
+ const HWPipeInfo &hw_pipe = (count == 0) ? left_pipe : right_pipe;
HWRotateInfo* hw_rotate_info = &hw_rotator_session->hw_rotate_info[count];
scalar::PipeInfo* pipe = (count == 0) ? &layer_info.left_pipe : &layer_info.right_pipe;
if (hw_rotate_info->valid) {
width = UINT32(hw_rotate_info->dst_roi.right - hw_rotate_info->dst_roi.left);
+ height = UINT32(hw_rotate_info->dst_roi.bottom - hw_rotate_info->dst_roi.top);
format = hw_rotator_session->output_buffer.format;
}
pipe->flags = flags;
- pipe->scale_data = GetScaleRef(i, !count);
- pipe->scale_data->src_width = width;
+ pipe->scale_data = (count == 0) ? &left_scale : &right_scale;
+ pipe->src_width = width;
+ pipe->src_height = height;
SetPipeInfo(hw_pipe, pipe);
}
layer_info.src_format = GetScalarFormat(format);
@@ -184,57 +216,52 @@
layer_info.right_pipe.dst_rect.w, layer_info.right_pipe.dst_rect.h);
// Configure scale data structure
- if (ScalarConfigureScale(&layer_info) < 0) {
+ if (configure_scale_(&layer_info) < 0) {
DLOGE("Scalar library failed to configure scale data!");
- return false;
+ return kErrorParameters;
}
- // Update Src Roi in HWPipeInfo
- if (layer_info.left_pipe.scale_data->enable_pxl_ext)
- UpdateSrcRoi(&layer_info.left_pipe, left_pipe);
- if (layer_info.right_pipe.scale_data->enable_pxl_ext)
- UpdateSrcRoi(&layer_info.right_pipe, right_pipe);
+ // Set ScaleData and update SrcRoi in HWPipeInfo
+ if (left_scale.enable_pxl_ext) {
+ SetScaleData(layer_info.left_pipe, &left_pipe.scale_data);
+ UpdateSrcRoi(layer_info.left_pipe, &left_pipe);
+ }
+ if (right_scale.enable_pxl_ext) {
+ SetScaleData(layer_info.right_pipe, &right_pipe.scale_data);
+ UpdateSrcRoi(layer_info.right_pipe, &right_pipe);
+ }
}
- return true;
+
+ return kErrorNone;
}
-
-void ScalarHelper::UpdateSrcWidth(uint32_t index, bool left, uint32_t* width) {
- *width = GetScaleRef(index, left)->src_width;
-}
-
-void ScalarHelper::SetScaleData(uint32_t index, bool left, mdp_scale_data* mdp_scale) {
-
- if (!lib_scalar_handle_ || !ScalarConfigureScale)
- return;
-
- scalar::Scale* scale = GetScaleRef(index, left);
- mdp_scale->enable_pxl_ext = scale->enable_pxl_ext;
-
- for (int i = 0; i < MAX_PLANES; i++) {
- mdp_scale->init_phase_x[i] = scale->init_phase_x[i];
- mdp_scale->phase_step_x[i] = scale->phase_step_x[i];
- mdp_scale->init_phase_y[i] = scale->init_phase_y[i];
- mdp_scale->phase_step_y[i] = scale->phase_step_y[i];
-
- mdp_scale->num_ext_pxls_left[i] = scale->left.extension[i];
- mdp_scale->num_ext_pxls_top[i] = scale->top.extension[i];
- mdp_scale->num_ext_pxls_right[i] = scale->right.extension[i];
- mdp_scale->num_ext_pxls_btm[i] = scale->bottom.extension[i];
-
- mdp_scale->left_ftch[i] = scale->left.overfetch[i];
- mdp_scale->top_ftch[i] = scale->top.overfetch[i];
- mdp_scale->right_ftch[i] = scale->right.overfetch[i];
- mdp_scale->btm_ftch[i] = scale->bottom.overfetch[i];
-
- mdp_scale->left_rpt[i] = scale->left.repeat[i];
- mdp_scale->top_rpt[i] = scale->top.repeat[i];
- mdp_scale->right_rpt[i] = scale->right.repeat[i];
- mdp_scale->btm_rpt[i] = scale->bottom.repeat[i];
-
- mdp_scale->roi_w[i] = scale->roi_width[i];
- }
-}
-
-} // namespace sde
-
#endif
+
+DisplayError Scalar::CreateScalar(Scalar **scalar) {
+ Scalar *scalar_obj = NULL;
+
+#ifdef USES_SCALAR
+ scalar_obj = new ScalarHelper();
+ if (scalar_obj) {
+ if (scalar_obj->Init() == kErrorNone) {
+ goto OnSuccess;
+ } else {
+ delete scalar_obj;
+ }
+ }
+#endif
+
+ scalar_obj = new Scalar();
+ if (!scalar_obj) {
+ return kErrorMemory;
+ }
+
+OnSuccess:
+ *scalar = scalar_obj;
+ return kErrorNone;
+}
+
+void Scalar::Destroy(Scalar *scalar) {
+ scalar->Deinit();
+}
+
+} // namespace sde
diff --git a/displayengine/libs/core/scalar_helper.h b/displayengine/libs/core/scalar_helper.h
index a54cb0c..35217c5 100755
--- a/displayengine/libs/core/scalar_helper.h
+++ b/displayengine/libs/core/scalar_helper.h
@@ -25,43 +25,47 @@
#ifndef __SCALAR_HELPER_H__
#define __SCALAR_HELPER_H__
-#ifdef USES_SCALAR
-
-#include <sys/types.h>
-#include <linux/msm_mdp_ext.h>
#include <hw_interface.h>
+#ifdef USES_SCALAR
#include <scalar.h>
-
-#define SCALAR_LIBRARY_NAME "libscalar.so"
+#endif
namespace sde {
-class ScalarHelper {
-
+class Scalar {
public:
- void Init();
- void Deinit();
- bool ConfigureScale(HWLayers *hw_layers);
- void UpdateSrcWidth(uint32_t index, bool left, uint32_t* src_width);
- void SetScaleData(uint32_t index, bool left, mdp_scale_data* mdp_scale);
- static ScalarHelper* GetInstance();
+ static DisplayError CreateScalar(Scalar **scalar);
+ static void Destroy(Scalar *scalar);
+ virtual ~Scalar() { }
+ virtual DisplayError ConfigureScale(HWLayers *hw_layers) { return kErrorNone; }
+
+ protected:
+ virtual DisplayError Init() { return kErrorNone; }
+ virtual void Deinit() { }
+};
+
+#ifdef USES_SCALAR
+class ScalarHelper : public Scalar {
+ public:
+ ScalarHelper();
+ virtual DisplayError ConfigureScale(HWLayers *hw_layers);
+
+ protected:
+ virtual DisplayError Init();
+ virtual void Deinit();
private:
- explicit ScalarHelper() { }
- struct ScaleData {
- scalar::Scale left_scale;
- scalar::Scale right_scale;
- };
- struct ScaleData scale_data_[kMaxSDELayers];
- void* lib_scalar_handle_;
- int (*ScalarConfigureScale)(struct scalar::LayerInfo* layer);
- scalar::Scale* GetScaleRef(uint32_t index, bool left) {
- return (left ? &scale_data_[index].left_scale : &scale_data_[index].right_scale);
- }
- static ScalarHelper* scalar_helper_; // Singleton Instance
+ const char *scalar_library_name_;
+ const char *configure_scale_api_;
+ void* lib_scalar_;
+ int (*configure_scale_)(scalar::LayerInfo *layer);
+ void SetPipeInfo(const HWPipeInfo &hw_pipe, scalar::PipeInfo *pipe);
+ void UpdateSrcRoi(const scalar::PipeInfo &pipe, HWPipeInfo *hw_pipe);
+ void SetScaleData(const scalar::PipeInfo &pipe, ScaleData *scale_data);
+ uint32_t GetScalarFormat(LayerBufferFormat source);
};
+#endif
} // namespace sde
-#endif
#endif // __SCALAR_HELPER_H__
diff --git a/displayengine/libs/core/session_manager.cpp b/displayengine/libs/core/session_manager.cpp
index f87bf10..dd4c29a 100644
--- a/displayengine/libs/core/session_manager.cpp
+++ b/displayengine/libs/core/session_manager.cpp
@@ -59,23 +59,28 @@
buffer_sync_handler_(buffer_sync_handler), active_session_count_(0) {
}
-void SessionManager::Start() {
+void SessionManager::Start(const int &client_id) {
+ SCOPE_LOCK(locker_);
+
uint32_t session_count = 0;
- uint32_t ready_session_count = 0;
+ uint32_t acquired_session_count = 0;
// Change the state of acquired session to kSessionReady
- while ((ready_session_count < active_session_count_) && (session_count < kMaxSessionCount)) {
- if (session_list_[session_count].state == kSessionReleased) {
- session_count++;
- continue;
+ while ((acquired_session_count < active_session_count_) && (session_count < kMaxSessionCount)) {
+ if (session_list_[session_count].state == kSessionAcquired) {
+ if (session_list_[session_count].client_id == client_id) {
+ session_list_[session_count].state = kSessionReady;
+ }
+ acquired_session_count++;
}
-
- session_list_[session_count++].state = kSessionReady;
- ready_session_count++;
+ session_count++;
}
}
-DisplayError SessionManager::OpenSession(HWRotatorSession *hw_rotator_session) {
+DisplayError SessionManager::OpenSession(const int &client_id,
+ HWRotatorSession *hw_rotator_session) {
+ SCOPE_LOCK(locker_);
+
DisplayError error = kErrorNone;
const HWSessionConfig &input_config = hw_rotator_session->hw_session_config;
@@ -90,12 +95,12 @@
uint32_t free_session = active_session_count_;
uint32_t acquired_session = kMaxSessionCount;
- uint32_t ready_session_count = 0;
+ uint32_t active_session_count = 0;
// First look for a session in ready state, if no session found in ready state matching
// with current input session config, assign a session in released state.
for (uint32_t session_count = 0; session_count < kMaxSessionCount &&
- ready_session_count < active_session_count_; session_count++) {
+ active_session_count < active_session_count_; session_count++) {
HWSessionConfig &hw_session_config =
session_list_[session_count].hw_rotator_session.hw_session_config;
@@ -104,17 +109,15 @@
continue;
}
- if (session_list_[session_count].state != kSessionReady) {
- continue;
+ if (session_list_[session_count].state == kSessionReady) {
+ if (session_list_[session_count].client_id == client_id &&
+ input_config == hw_session_config) {
+ session_list_[session_count].state = kSessionAcquired;
+ acquired_session = session_count;
+ break;
+ }
}
-
- if (input_config == hw_session_config) {
- session_list_[session_count].state = kSessionAcquired;
- acquired_session = session_count;
- break;
- }
-
- ready_session_count++;
+ active_session_count++;
}
// If the input config does not match with existing config, then add new session and change the
@@ -131,31 +134,31 @@
acquired_session = free_session;
hw_rotator_session->session_id = acquired_session;
+ session_list_[acquired_session].client_id = client_id;
active_session_count_++;
DLOGV_IF(kTagRotator, "Acquire new session Output: width = %d, height = %d, format = %d, " \
- "session_id %d", hw_rotator_session->output_buffer.width,
+ "session_id %d, client_id %d", hw_rotator_session->output_buffer.width,
hw_rotator_session->output_buffer.height, hw_rotator_session->output_buffer.format,
- hw_rotator_session->session_id);
+ hw_rotator_session->session_id, client_id);
return kErrorNone;
}
- hw_rotator_session->output_buffer.width = input_config.dst_width;
- hw_rotator_session->output_buffer.height = input_config.dst_height;
- hw_rotator_session->output_buffer.format = input_config.dst_format;
- hw_rotator_session->output_buffer.flags.secure = input_config.secure;
- hw_rotator_session->session_id = acquired_session;
+ *hw_rotator_session = session_list_[acquired_session].hw_rotator_session;
DLOGV_IF(kTagRotator, "Acquire existing session Output: width = %d, height = %d, format = %d, " \
- "session_id %d", hw_rotator_session->output_buffer.width,
+ "session_id %d, client_id %d", hw_rotator_session->output_buffer.width,
hw_rotator_session->output_buffer.height, hw_rotator_session->output_buffer.format,
- hw_rotator_session->session_id);
+ hw_rotator_session->session_id, client_id);
return kErrorNone;
}
-DisplayError SessionManager::GetNextBuffer(HWRotatorSession *hw_rotator_session) {
+DisplayError SessionManager::GetNextBuffer(const int &client_id,
+ HWRotatorSession *hw_rotator_session) {
+ SCOPE_LOCK(locker_);
+
DisplayError error = kErrorNone;
int session_id = hw_rotator_session->session_id;
@@ -166,7 +169,7 @@
Session *session = &session_list_[session_id];
if (session->state != kSessionAcquired) {
DLOGE("Invalid session state %d", session->state);
- kErrorParameters;
+ return kErrorParameters;
}
uint32_t curr_index = session->curr_index;
@@ -195,33 +198,38 @@
hw_rotator_session->output_buffer.planes[0].fd = buffer_info->alloc_buffer_info.fd;
hw_rotator_session->output_buffer.planes[0].offset = session->offset[curr_index];
+ session->hw_rotator_session = *hw_rotator_session;
+
DLOGI_IF(kTagRotator, "Output: width = %d, height = %d, format = %d, stride %d, " \
- "curr_index = %d, offset %d, fd %d, session_id %d,",
+ "curr_index = %d, offset %d, fd %d, session_id %d, client_id %d",
hw_rotator_session->output_buffer.width, hw_rotator_session->output_buffer.height,
hw_rotator_session->output_buffer.format,
hw_rotator_session->output_buffer.planes[0].stride, curr_index,
hw_rotator_session->output_buffer.planes[0].offset,
- hw_rotator_session->output_buffer.planes[0].fd, hw_rotator_session->session_id);
+ hw_rotator_session->output_buffer.planes[0].fd, session_id, client_id);
return kErrorNone;
}
-DisplayError SessionManager::Stop() {
+DisplayError SessionManager::Stop(const int &client_id) {
+ SCOPE_LOCK(locker_);
+
DisplayError error = kErrorNone;
uint32_t session_id = 0;
// Release all the sessions which were not acquired in the current cycle and deallocate the
// buffers associated with it.
while ((active_session_count_ > 0) && (session_id < kMaxSessionCount)) {
- if (session_list_[session_id].state == kSessionReady) {
+ if (session_list_[session_id].state == kSessionReady &&
+ session_list_[session_id].client_id == client_id) {
error = ReleaseSession(&session_list_[session_id]);
if (error != kErrorNone) {
return error;
}
active_session_count_--;
- DLOGI_IF(kTagRotator, "session_id = %d, active_session_count = %d", session_id,
- active_session_count_);
+ DLOGI_IF(kTagRotator, "session_id = %d, active_session_count = %d, client_id %d", session_id,
+ active_session_count_, client_id);
}
session_id++;
}
@@ -229,7 +237,10 @@
return kErrorNone;
}
-DisplayError SessionManager::SetReleaseFd(HWRotatorSession *hw_rotator_session) {
+DisplayError SessionManager::SetReleaseFd(const int &client_id,
+ HWRotatorSession *hw_rotator_session) {
+ SCOPE_LOCK(locker_);
+
int session_id = hw_rotator_session->session_id;
if (session_id > kMaxSessionCount) {
return kErrorParameters;
@@ -238,7 +249,7 @@
Session *session = &session_list_[session_id];
if (session->state != kSessionAcquired) {
DLOGE("Invalid session state %d", session->state);
- kErrorParameters;
+ return kErrorParameters;
}
uint32_t &curr_index = session->curr_index;
@@ -251,8 +262,8 @@
curr_index = (curr_index + 1) % buffer_count;
- DLOGI_IF(kTagRotator, "session_id %d, curr_index = %d, release fd %d", session_id,
- curr_index, hw_rotator_session->output_buffer.release_fence_fd);
+ DLOGI_IF(kTagRotator, "session_id %d, curr_index = %d, release fd %d, client_id %d", session_id,
+ curr_index, hw_rotator_session->output_buffer.release_fence_fd, client_id);
return kErrorNone;
}
@@ -333,7 +344,9 @@
session->release_fd[idx] = -1;
}
}
+
session->state = kSessionReleased;
+ session->client_id == -1;
if (session->offset) {
delete[] session->offset;
diff --git a/displayengine/libs/core/session_manager.h b/displayengine/libs/core/session_manager.h
index b27ba8b..3324c3e 100644
--- a/displayengine/libs/core/session_manager.h
+++ b/displayengine/libs/core/session_manager.h
@@ -43,11 +43,11 @@
SessionManager(HWRotatorInterface *hw_intf, BufferAllocator *buffer_allocator,
BufferSyncHandler *buffer_sync_handler);
- void Start();
- DisplayError Stop();
- DisplayError OpenSession(HWRotatorSession *hw_rotator_session);
- DisplayError GetNextBuffer(HWRotatorSession *hw_rotator_session);
- DisplayError SetReleaseFd(HWRotatorSession *hw_rotator_session);
+ void Start(const int &client_id);
+ DisplayError Stop(const int &client_id);
+ DisplayError OpenSession(const int &client_id, HWRotatorSession *hw_rotator_session);
+ DisplayError GetNextBuffer(const int &client_id, HWRotatorSession *hw_rotator_session);
+ DisplayError SetReleaseFd(const int &client_id, HWRotatorSession *hw_rotator_session);
private:
// TODO(user): Read from hw capability instead of hardcoding
@@ -66,13 +66,16 @@
int *release_fd;
uint32_t *offset;
uint32_t curr_index;
+ int client_id;
- Session() : state(kSessionReleased), release_fd(NULL), offset(NULL), curr_index(0) { }
+ Session() : state(kSessionReleased), release_fd(NULL), offset(NULL), curr_index(0),
+ client_id(-1) { }
};
DisplayError AcquireSession(HWRotatorSession *hw_rotator_session, Session *session);
DisplayError ReleaseSession(Session *session);
+ Locker locker_;
Session session_list_[kMaxSessionCount];
HWRotatorInterface *hw_rotator_intf_;
BufferAllocator *buffer_allocator_;
diff --git a/libgralloc/alloc_controller.cpp b/libgralloc/alloc_controller.cpp
index b8e6a64..e37cddd 100644
--- a/libgralloc/alloc_controller.cpp
+++ b/libgralloc/alloc_controller.cpp
@@ -49,17 +49,28 @@
#define ASTC_BLOCK_SIZE 16
-#ifdef ION_FLAG_CP_PIXEL
-#define CP_HEAP_ID ION_SECURE_HEAP_ID
-#else
+#ifndef ION_FLAG_CP_PIXEL
#define ION_FLAG_CP_PIXEL 0
-#define CP_HEAP_ID ION_CP_MM_HEAP_ID
#endif
#ifndef ION_FLAG_ALLOW_NON_CONTIG
#define ION_FLAG_ALLOW_NON_CONTIG 0
#endif
+#ifdef MASTER_SIDE_CP
+#define CP_HEAP_ID ION_SECURE_HEAP_ID
+/* Please Add the new SD ION Heap here */
+#define SD_HEAP_ID 0
+#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_CP_PIXEL)
+/* Please Add the new SD ION Flag here */
+#define ION_SD_FLAGS ION_SECURE
+#else // SLAVE_SIDE_CP
+#define CP_HEAP_ID ION_CP_MM_HEAP_ID
+#define SD_HEAP_ID CP_HEAP_ID
+#define ION_CP_FLAGS (ION_SECURE | ION_FLAG_ALLOW_NON_CONTIG)
+#define ION_SD_FLAGS ION_SECURE
+#endif
+
using namespace gralloc;
using namespace qdutils;
@@ -108,6 +119,16 @@
*(void **)&LINK_adreno_isUBWCSupportedByGpu =
::dlsym(libadreno_utils, "isUBWCSupportedByGpu");
}
+
+ // Check if the overriding property debug.gralloc.gfx_ubwc_disable
+ // that disables UBWC allocations for the graphics stack is set
+ gfx_ubwc_disable = 0;
+ char property[PROPERTY_VALUE_MAX];
+ property_get("debug.gralloc.gfx_ubwc_disable", property, "0");
+ if(!(strncmp(property, "1", PROPERTY_VALUE_MAX)) ||
+ !(strncmp(property, "true", PROPERTY_VALUE_MAX))) {
+ gfx_ubwc_disable = 1;
+ }
}
AdrenoMemInfo::~AdrenoMemInfo()
@@ -282,7 +303,7 @@
int AdrenoMemInfo::isUBWCSupportedByGPU(int format)
{
- if (libadreno_utils) {
+ if (!gfx_ubwc_disable && libadreno_utils) {
if (LINK_adreno_isUBWCSupportedByGpu) {
ADRENOPIXELFORMAT gpu_format = getGpuPixelFormat(format);
return LINK_adreno_isUBWCSupportedByGpu(gpu_format);
@@ -347,21 +368,16 @@
if(usage & GRALLOC_USAGE_PROTECTED) {
if (usage & GRALLOC_USAGE_PRIVATE_MM_HEAP) {
- ionHeapId = ION_HEAP(CP_HEAP_ID);
- ionFlags |= ION_SECURE;
if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
+ ionHeapId = ION_HEAP(SD_HEAP_ID);
/*
* There is currently no flag in ION for Secure Display
- * VM. Please add it here once available.
- *
- ionFlags |= <Ion flag for Secure Display>;
+ * VM. Please add it to the define once available.
*/
+ ionFlags |= ION_SD_FLAGS;
} else {
- ionFlags |= ION_FLAG_CP_PIXEL;
- }
-
- if (!(usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY)) {
- ionFlags |= ION_FLAG_ALLOW_NON_CONTIG;
+ ionHeapId = ION_HEAP(CP_HEAP_ID);
+ ionFlags |= ION_CP_FLAGS;
}
} else {
// for targets/OEMs which do not need HW level protection
@@ -912,3 +928,38 @@
}
return size;
}
+
+int getRgbDataAddress(private_handle_t* hnd, void* rgb_data)
+{
+ int err = 0;
+
+ // This api is for RGB* formats
+ if (hnd->format > HAL_PIXEL_FORMAT_sRGB_X_8888) {
+ return -EINVAL;
+ }
+
+ // linear buffer
+ if (!(hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED)) {
+ rgb_data = (void*)hnd->base;
+ return err;
+ }
+
+ unsigned int meta_size = 0;
+ switch (hnd->format) {
+ case HAL_PIXEL_FORMAT_RGB_565:
+ meta_size = getUBwcMetaBufferSize(hnd->width, hnd->height, 2);
+ break;
+ case HAL_PIXEL_FORMAT_RGBA_8888:
+ case HAL_PIXEL_FORMAT_RGBX_8888:
+ case HAL_PIXEL_FORMAT_sRGB_A_8888:
+ meta_size = getUBwcMetaBufferSize(hnd->width, hnd->height, 4);
+ break;
+ default:
+ ALOGE("%s:Unsupported RGB format: 0x%x", __FUNCTION__, hnd->format);
+ err = -EINVAL;
+ break;
+ }
+
+ rgb_data = (void*)(hnd->base + meta_size);
+ return err;
+}
diff --git a/libgralloc/gpu.cpp b/libgralloc/gpu.cpp
index 53363bb..0fd6e3b 100644
--- a/libgralloc/gpu.cpp
+++ b/libgralloc/gpu.cpp
@@ -34,7 +34,7 @@
#define SZ_1M 0x100000
#define SZ_4K 0x1000
-#ifdef ION_FLAG_CP_PIXEL
+#ifdef MASTER_SIDE_CP
#define SECURE_ALIGN SZ_4K
#else
#define SECURE_ALIGN SZ_1M
@@ -308,6 +308,25 @@
grallocFormat = HAL_PIXEL_FORMAT_RGBA_8888;
}
+ bool useFbMem = false;
+ char property[PROPERTY_VALUE_MAX];
+ char isUBWC[PROPERTY_VALUE_MAX];
+ if (usage & GRALLOC_USAGE_HW_FB) {
+ if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
+ (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
+ (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
+ useFbMem = true;
+ } else {
+ if (property_get("debug.gralloc.enable_fb_ubwc", isUBWC, NULL) > 0){
+ if ((!strncmp(isUBWC, "1", PROPERTY_VALUE_MAX)) ||
+ (!strncasecmp(isUBWC, "true", PROPERTY_VALUE_MAX))) {
+ // Allocate UBWC aligned framebuffer
+ usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
+ }
+ }
+ }
+ }
+
getGrallocInformationFromFormat(grallocFormat, &bufferType);
size = getBufferSizeAndDimensions(w, h, grallocFormat, usage, alignedw,
alignedh);
@@ -316,15 +335,6 @@
return -EINVAL;
size = (bufferSize >= size)? bufferSize : size;
- bool useFbMem = false;
- char property[PROPERTY_VALUE_MAX];
- if((usage & GRALLOC_USAGE_HW_FB) &&
- (property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
- (!strncmp(property, "1", PROPERTY_VALUE_MAX ) ||
- (!strncasecmp(property,"true", PROPERTY_VALUE_MAX )))) {
- useFbMem = true;
- }
-
int err = 0;
if(useFbMem) {
err = gralloc_alloc_framebuffer(usage, pHandle);
diff --git a/libgralloc/gr.h b/libgralloc/gr.h
index 5ee0cf8..98b4eec 100644
--- a/libgralloc/gr.h
+++ b/libgralloc/gr.h
@@ -71,6 +71,7 @@
int alloc_buffer(private_handle_t **pHnd, int w, int h, int format, int usage);
void free_buffer(private_handle_t *hnd);
int getYUVPlaneInfo(private_handle_t* pHnd, struct android_ycbcr* ycbcr);
+int getRgbDataAddress(private_handle_t* pHnd, void* rgb_data);
// To query if UBWC is enabled, based on format and usage flags
bool isUBwcEnabled(int format, int usage);
@@ -148,6 +149,8 @@
ADRENOPIXELFORMAT getGpuPixelFormat(int hal_format);
private:
+ // Overriding flag to disable UBWC alloc for graphics stack
+ int gfx_ubwc_disable;
// Pointer to the padding library.
void *libadreno_utils;
diff --git a/libgralloc/gralloc_priv.h b/libgralloc/gralloc_priv.h
index 676c3bc..6998296 100755
--- a/libgralloc/gralloc_priv.h
+++ b/libgralloc/gralloc_priv.h
@@ -85,6 +85,7 @@
#define GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO 7
#define GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO 8
#define GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG 9
+#define GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS 10
/* OEM specific HAL formats */
diff --git a/libgralloc/mapper.cpp b/libgralloc/mapper.cpp
index acac5b4..7d4e8ce 100644
--- a/libgralloc/mapper.cpp
+++ b/libgralloc/mapper.cpp
@@ -66,8 +66,11 @@
unsigned int size = 0;
int err = 0;
IMemAlloc* memalloc = getAllocator(hnd->flags) ;
- void *mappedAddress;
- // Dont map FRAMEBUFFER and SECURE_BUFFERS
+ void *mappedAddress = MAP_FAILED;
+ hnd->base = 0;
+ hnd->base_metadata = 0;
+
+ // Dont map framebuffer and secure buffers
if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER) &&
!(hnd->flags & private_handle_t::PRIV_FLAGS_SECURE_BUFFER)) {
size = hnd->size;
@@ -76,14 +79,14 @@
if(err || mappedAddress == MAP_FAILED) {
ALOGE("Could not mmap handle %p, fd=%d (%s)",
handle, hnd->fd, strerror(errno));
- hnd->base = 0;
return -errno;
}
hnd->base = uint64_t(mappedAddress) + hnd->offset;
}
- //Allow mapping of metadata for all buffers and SECURE_BUFFER
+ //Allow mapping of metadata for all buffers including secure ones, but not
+ //of framebuffer
if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
mappedAddress = MAP_FAILED;
size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
@@ -92,7 +95,6 @@
if(err || mappedAddress == MAP_FAILED) {
ALOGE("Could not mmap handle %p, fd=%d (%s)",
handle, hnd->fd_metadata, strerror(errno));
- hnd->base_metadata = 0;
return -errno;
}
hnd->base_metadata = uint64_t(mappedAddress) + hnd->offset_metadata;
@@ -104,32 +106,37 @@
buffer_handle_t handle)
{
ATRACE_CALL();
+ int err = -EINVAL;
if(!module)
- return -EINVAL;
+ return err;
private_handle_t* hnd = (private_handle_t*)handle;
- if (!(hnd->flags & private_handle_t::PRIV_FLAGS_FRAMEBUFFER)) {
- int err = -EINVAL;
- void* base = (void*)hnd->base;
- unsigned int size = hnd->size;
- IMemAlloc* memalloc = getAllocator(hnd->flags) ;
- if(memalloc != NULL) {
- err = memalloc->unmap_buffer(base, size, hnd->offset);
- if (err) {
- ALOGE("Could not unmap memory at address %p", base);
- }
- base = (void*)hnd->base_metadata;
- size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
- err = memalloc->unmap_buffer(base, size, hnd->offset_metadata);
- if (err) {
- ALOGE("Could not unmap memory at address %p", base);
- }
+ IMemAlloc* memalloc = getAllocator(hnd->flags) ;
+ if(!memalloc)
+ return err;
+
+ if(hnd->base) {
+ err = memalloc->unmap_buffer((void*)hnd->base, hnd->size, hnd->offset);
+ if (err) {
+ ALOGE("Could not unmap memory at address %p, %s", hnd->base,
+ strerror(errno));
+ return -errno;
}
+ hnd->base = 0;
}
- /* need to initialize the pointer to NULL otherwise unmapping for that
- * buffer happens twice which leads to crash */
- hnd->base = 0;
- hnd->base_metadata = 0;
+
+ if(hnd->base_metadata) {
+ unsigned int size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
+ err = memalloc->unmap_buffer((void*)hnd->base_metadata,
+ size, hnd->offset_metadata);
+ if (err) {
+ ALOGE("Could not unmap memory at address %p, %s",
+ hnd->base_metadata, strerror(errno));
+ return -errno;
+ }
+ hnd->base_metadata = 0;
+ }
+
return 0;
}
@@ -146,8 +153,6 @@
if (!module || private_handle_t::validate(handle) < 0)
return -EINVAL;
- // In this implementation, we don't need to do anything here
-
/* NOTE: we need to initialize the buffer as not mapped/not locked
* because it shouldn't when this function is called the first time
* in a new process. Ideally these flags shouldn't be part of the
@@ -155,9 +160,6 @@
* out-of-line
*/
- private_handle_t* hnd = (private_handle_t*)handle;
- hnd->base = 0;
- hnd->base_metadata = 0;
int err = gralloc_map(module, handle);
if (err) {
ALOGE("%s: gralloc_map failed", __FUNCTION__);
@@ -178,16 +180,9 @@
* If the buffer has been mapped during a lock operation, it's time
* to un-map it. It's an error to be here with a locked buffer.
* NOTE: the framebuffer is handled differently and is never unmapped.
+ * Also base and base_metadata are reset.
*/
-
- private_handle_t* hnd = (private_handle_t*)handle;
-
- if (hnd->base != 0) {
- gralloc_unmap(module, handle);
- }
- hnd->base = 0;
- hnd->base_metadata = 0;
- return 0;
+ return gralloc_unmap(module, handle);
}
int terminateBuffer(gralloc_module_t const* module,
@@ -200,20 +195,10 @@
/*
* If the buffer has been mapped during a lock operation, it's time
* to un-map it. It's an error to be here with a locked buffer.
+ * NOTE: the framebuffer is handled differently and is never unmapped.
+ * Also base and base_metadata are reset.
*/
-
- if (hnd->base != 0) {
- // this buffer was mapped, unmap it now
- if (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) {
- gralloc_unmap(module, hnd);
- } else {
- ALOGE("terminateBuffer: unmapping a non pmem/ashmem buffer flags = 0x%x",
- hnd->flags);
- gralloc_unmap(module, hnd);
- }
- }
-
- return 0;
+ return gralloc_unmap(module, hnd);
}
static int gralloc_map_and_invalidate (gralloc_module_t const* module,
@@ -457,6 +442,15 @@
res = 0;
} break;
+ case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS:
+ {
+ private_handle_t* hnd = va_arg(args, private_handle_t*);
+ void* rgb_data = va_arg(args, void*);
+ if (!private_handle_t::validate(hnd)) {
+ res = getRgbDataAddress(hnd, rgb_data);
+ }
+ } break;
+
default:
break;
}
diff --git a/libhwcomposer/hwc.cpp b/libhwcomposer/hwc.cpp
index 1fa40ce..c51efba 100644
--- a/libhwcomposer/hwc.cpp
+++ b/libhwcomposer/hwc.cpp
@@ -281,13 +281,15 @@
hwc_context_t* ctx = (hwc_context_t*)(dev);
const int dpy = HWC_DISPLAY_PRIMARY;
bool fbComp = false;
-
+ static int compStart = false;
if (!ctx->mBootAnimCompleted)
processBootAnimCompleted(ctx);
- if (LIKELY(list && list->numHwLayers > 1) && ctx->dpyAttr[dpy].connected &&
- (ctx->dpyAttr[dpy].isActive ||
+ if (LIKELY(list && (list->numHwLayers > 1 ||
+ (ctx->mMDP.version < qdutils::MDP_V4_0 && compStart))) &&
+ ctx->dpyAttr[dpy].connected && (ctx->dpyAttr[dpy].isActive ||
ctx->mHDMIDisplay->isHDMIPrimaryDisplay())
&& !ctx->dpyAttr[dpy].isPause) {
+ compStart = true;
// When HDMI is primary we should rely on the first valid
// draw call in order to activate the display
diff --git a/libhwcomposer/hwc_copybit.cpp b/libhwcomposer/hwc_copybit.cpp
index e223ff4..00bd643 100644
--- a/libhwcomposer/hwc_copybit.cpp
+++ b/libhwcomposer/hwc_copybit.cpp
@@ -174,11 +174,20 @@
//dirty rect for same layer at least equal of number of
//framebuffers
- if ( updatingLayerCount == 1 ) {
- hwc_rect_t dirtyRect = list->hwLayers[changingLayerIndex].displayFrame;
+ if ( updatingLayerCount <= 1 ) {
+ hwc_rect_t dirtyRect;
+ 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;
+ dirtyRect = list->hwLayers[changingLayerIndex].dirtyRect;
#endif
+ }
for (int k = ctx->listStats[dpy].numAppLayers-1; k >= 0 ; k--) {
//disable swap rect in case of scaling and video .
@@ -553,11 +562,13 @@
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 (CBUtils::getuiClearRegion(list, clearRegion, layerProp,
- mDirtyLayerIndex)) {
+ 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
@@ -569,8 +580,13 @@
}else
clear(renderBuffer, clearRegion);
}
- if (mDirtyLayerIndex != -1)
- mDirtyRect = list->hwLayers[mDirtyLayerIndex].displayFrame;
+ if (mDirtyLayerIndex != -1) {
+ if (mDirtyLayerIndex == NO_UPDATING_LAYER) {
+ mDirtyRect = clearRegion;
+ } else {
+ mDirtyRect = list->hwLayers[mDirtyLayerIndex].displayFrame;
+ }
+ }
// numAppLayers-1, as we iterate from 0th layer index with HWC_COPYBIT flag
for (int i = 0; i <= (ctx->listStats[dpy].numAppLayers-1); i++) {
diff --git a/libhwcomposer/hwc_copybit.h b/libhwcomposer/hwc_copybit.h
index 4223aa0..993c790 100644
--- a/libhwcomposer/hwc_copybit.h
+++ b/libhwcomposer/hwc_copybit.h
@@ -28,6 +28,8 @@
#define MAX_SCALE_FACTOR 16
#define MIN_SCALE_FACTOR 0.0625
#define MAX_LAYERS_FOR_ABC 2
+#define INVALID_DIMENSION -1
+#define NO_UPDATING_LAYER -2
namespace qhwc {
class CopyBit {
diff --git a/libhwcomposer/hwc_mdpcomp.cpp b/libhwcomposer/hwc_mdpcomp.cpp
index 5bd7931..e2c4677 100644
--- a/libhwcomposer/hwc_mdpcomp.cpp
+++ b/libhwcomposer/hwc_mdpcomp.cpp
@@ -55,6 +55,7 @@
int (*MDPComp::sPerfLockAcquire)(int, int, int*, int) = NULL;
int (*MDPComp::sPerfLockRelease)(int value) = NULL;
int MDPComp::sPerfHintWindow = -1;
+float MDPComp::sDownscaleThreshold = 1.0;
enum AllocOrder { FORMAT_YUV, FORMAT_RGB, FORMAT_MAX };
@@ -212,6 +213,10 @@
}
}
+ if(property_get("persist.hwc.downscale_threshold", property, "1.0") > 0) {
+ sDownscaleThreshold = (float)atof(property);
+ }
+
return true;
}
@@ -430,6 +435,24 @@
//More conditions here, sRGB+Blend etc
return false;
}
+
+ //In targets with fewer pipes, frequent composition switch between MDP/GPU
+ //can happen for a layer due to lack of pipes. When this switch happens
+ //continuously for RGB downscaled layer with downscale greater than
+ //threshold, it appears as flicker as output
+ //of MDP and GPU are different as they use different filters for downscale.
+ //To avoid this flicker, punt RGB downscaled layer with downscale greater
+ //than threshold value to GPU always.
+ if((sDownscaleThreshold > 1.0)) {
+ if(((not isYuvBuffer(hnd))
+ and (not isDownscaleWithinThreshold(layer,
+ sDownscaleThreshold)))) {
+ ALOGD_IF(isDebug(), "%s: required downscale is greater than \
+ threshold %f", __FUNCTION__, sDownscaleThreshold);
+ return false;
+ }
+ }
+
return true;
}
diff --git a/libhwcomposer/hwc_mdpcomp.h b/libhwcomposer/hwc_mdpcomp.h
index db68e82..5c43aa7 100644
--- a/libhwcomposer/hwc_mdpcomp.h
+++ b/libhwcomposer/hwc_mdpcomp.h
@@ -283,6 +283,7 @@
static int (*sPerfLockAcquire)(int, int, int*, int);
static int (*sPerfLockRelease)(int value);
static int sPerfHintWindow;
+ static float sDownscaleThreshold;
};
diff --git a/libhwcomposer/hwc_utils.cpp b/libhwcomposer/hwc_utils.cpp
index aeda428..79235ff 100644
--- a/libhwcomposer/hwc_utils.cpp
+++ b/libhwcomposer/hwc_utils.cpp
@@ -972,6 +972,27 @@
return false;
}
+
+bool isDownscaleWithinThreshold(hwc_layer_1_t const* layer, float threshold) {
+ hwc_rect_t displayFrame = layer->displayFrame;
+ hwc_rect_t sourceCrop = integerizeSourceCrop(layer->sourceCropf);
+ int dst_w, dst_h, src_w, src_h;
+ float downscale = 1.0;
+ dst_w = displayFrame.right - displayFrame.left;
+ dst_h = displayFrame.bottom - displayFrame.top;
+ src_w = sourceCrop.right - sourceCrop.left;
+ src_h = sourceCrop.bottom - sourceCrop.top;
+ if(dst_w && dst_h) {
+ float w_scale = ((float)src_w / (float)dst_w);
+ float h_scale = ((float)src_h / (float)dst_h);
+
+ if((w_scale > threshold) or (h_scale > threshold))
+ return false;
+ }
+
+ return true;
+}
+
bool needsScaling(hwc_layer_1_t const* layer) {
int dst_w, dst_h, src_w, src_h;
hwc_rect_t displayFrame = layer->displayFrame;
diff --git a/libhwcomposer/hwc_utils.h b/libhwcomposer/hwc_utils.h
index da0182b..4849baf 100644
--- a/libhwcomposer/hwc_utils.h
+++ b/libhwcomposer/hwc_utils.h
@@ -309,6 +309,7 @@
bool isAlphaScaled(hwc_layer_1_t const* layer);
bool needsScaling(hwc_layer_1_t const* layer);
bool isDownscaleRequired(hwc_layer_1_t const* layer);
+bool isDownscaleWithinThreshold(hwc_layer_1_t const* layer, float threshold);
bool needsScalingWithSplit(hwc_context_t* ctx, hwc_layer_1_t const* layer,
const int& dpy);
void sanitizeSourceCrop(hwc_rect_t& cropL, hwc_rect_t& cropR,
diff --git a/liboverlay/overlay.cpp b/liboverlay/overlay.cpp
index 113bd48..da24382 100644
--- a/liboverlay/overlay.cpp
+++ b/liboverlay/overlay.cpp
@@ -153,8 +153,6 @@
return getPipe_8x52(pipeSpecs);
} else if(MDPVersion::getInstance().is8994()) {
return getPipe_8994(pipeSpecs);
- } else if(MDPVersion::getInstance().is8992()) {
- return getPipe_8992(pipeSpecs);
}
eDest dest = OV_INVALID;
@@ -261,13 +259,6 @@
//supported since we at least need 1 round in between where the DMA is
//unused
eDest dest = OV_INVALID;
-
- // Reset format type to FORMAT_NONE to select the pipe irrespective of the
- // format specifed by the client. This is required for the device where
- // SMP starvation is unlikely, we need not keep track of formats
- // programmed in the pipes to avoid potential pipe crunching.
- resetPipeBookFormat(pipeSpecs.dpy);
-
if(pipeSpecs.formatClass == FORMAT_YUV) {
return nextPipe(OV_MDP_PIPE_VG, pipeSpecs);
} else {
@@ -279,14 +270,9 @@
dest = nextPipe(OV_MDP_PIPE_DMA, pipeSpecs);
}
}
-
return dest;
}
-utils::eDest Overlay::getPipe_8992(const PipeSpecs& pipeSpecs) {
- return getPipe_8994(pipeSpecs);
-}
-
void Overlay::endAllSessions() {
for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
if(mPipeBook[i].valid() && mPipeBook[i].mSession==PipeBook::START)
diff --git a/liboverlay/overlay.h b/liboverlay/overlay.h
index 2782fc2..affb4db 100644
--- a/liboverlay/overlay.h
+++ b/liboverlay/overlay.h
@@ -179,9 +179,6 @@
utils::eDest getPipe_8x39(const PipeSpecs& pipeSpecs);
utils::eDest getPipe_8x52(const PipeSpecs& pipeSpecs);
utils::eDest getPipe_8994(const PipeSpecs& pipeSpecs);
- utils::eDest getPipe_8992(const PipeSpecs& pipeSpecs);
-
- void resetPipeBookFormat(const int &dpy);
/* Returns the handle to libscale.so's programScale function */
static int (*getFnProgramScale())(struct mdp_overlay_list *);
@@ -448,14 +445,6 @@
return "Invalid";
}
-inline void Overlay::resetPipeBookFormat(const int &dpy) {
- for(int i = 0; i < PipeBook::NUM_PIPES; i++) {
- if (mPipeBook[i].mDisplay == dpy) {
- mPipeBook[i].mFormatType = FORMAT_NONE;
- }
- }
-}
-
}; // overlay
#endif // OVERLAY_H
diff --git a/liboverlay/overlayMdp.cpp b/liboverlay/overlayMdp.cpp
index 828f4fc..95bdc23 100644
--- a/liboverlay/overlayMdp.cpp
+++ b/liboverlay/overlayMdp.cpp
@@ -399,7 +399,7 @@
int errVal = mdp_wrapper::validateAndSet(fbFd, list);
if(errVal) {
/* No dump for failure due to insufficient resource */
- if(errVal != E2BIG) {
+ if(errVal != E2BIG && errVal != EBADSLT) {
//ENODEV is returned when the driver cannot satisfy a pipe request.
//This could happen if previous round's UNSET hasn't been commited
//yet, either because of a missed vsync or because of difference in