sdm: Use vector for layers and regions
Use vectors for Layers and Regions in LayerStack
to get rid of memory management
Change-Id: I8a420361e56dd34b415633b10281beaa58bc3bdf
Crs-fixed: 1006182
diff --git a/sdm/include/core/layer_buffer.h b/sdm/include/core/layer_buffer.h
index 47ebf92..7eba4e3 100644
--- a/sdm/include/core/layer_buffer.h
+++ b/sdm/include/core/layer_buffer.h
@@ -206,8 +206,9 @@
uint32_t height = 0; //!< Actual height of the Layer that this buffer is for.
uint32_t size = 0; //!< Size of a single buffer (even if multiple clubbed together)
LayerBufferFormat format = kFormatRGBA8888; //!< Format of the buffer content.
- LayerBufferPlane planes[4]; //!< Array of planes that this buffer contains. RGB buffer formats
- //!< have 1 plane whereas YUV buffer formats may have upto 4 planes.
+ LayerBufferPlane planes[4] = {};
+ //!< Array of planes that this buffer contains. RGB buffer formats
+ //!< have 1 plane whereas YUV buffer formats may have upto 4 planes
//!< Total number of planes for the buffer will be interpreted based
//!< on the buffer format specified.
diff --git a/sdm/include/core/layer_stack.h b/sdm/include/core/layer_stack.h
index ce1e5e6..3d86fbe 100644
--- a/sdm/include/core/layer_stack.h
+++ b/sdm/include/core/layer_stack.h
@@ -34,6 +34,8 @@
#include <stdint.h>
#include <utils/constants.h>
+#include <vector>
+
#include "layer_buffer.h"
#include "sdm_types.h"
@@ -264,23 +266,23 @@
//!< should be preserved between Prepare() and
//!< Commit() calls.
- LayerRect src_rect; //!< Rectangular area of the layer buffer to
+ LayerRect src_rect = {}; //!< Rectangular area of the layer buffer to
//!< consider for composition.
- LayerRect dst_rect; //!< The target position where the frame will be
+ LayerRect dst_rect = {}; //!< The target position where the frame will be
//!< displayed. Cropping rectangle is scaled to
//!< fit into this rectangle. The origin is the
//!< top-left corner of the screen.
- LayerRectArray visible_regions; //!< Visible rectangular areas in screen space.
+ std::vector<LayerRect> visible_regions = {}; //!< Visible rectangular areas in screen space.
//!< The visible region includes areas overlapped
//!< by a translucent layer.
- LayerRectArray dirty_regions; //!< Rectangular areas in the current frames
+ std::vector<LayerRect> dirty_regions = {}; //!< Rectangular areas in the current frames
//!< that have changed in comparison to
//!< previous frame.
- LayerRectArray blit_regions; //!< Rectangular areas of this layer which need
+ std::vector<LayerRect> blit_regions = {}; //!< Rectangular areas of this layer which need
//!< to be composed to blit target. Display
//!< device will update blit rectangles if a
//!< layer composition is set as hybrid. Nth blit
@@ -291,7 +293,7 @@
//!< applied on the layer buffer during
//!< composition.
- LayerTransform transform; //!< Rotation/Flip operations which need to be
+ LayerTransform transform = {}; //!< Rotation/Flip operations which need to be
//!< applied to the layer buffer during
//!< composition.
@@ -322,8 +324,7 @@
@sa DisplayInterface::Commit
*/
struct LayerStack {
- Layer *layers = NULL; //!< Array of layers.
- uint32_t layer_count = 0; //!< Total number of layers.
+ std::vector<Layer *> layers = {}; //!< Vector of layer pointers.
int retire_fence_fd = -1; //!< File descriptor referring to a sync fence object which
//!< will be signaled when this composited frame has been
diff --git a/sdm/include/private/resource_interface.h b/sdm/include/private/resource_interface.h
index c350460..21652f5 100644
--- a/sdm/include/private/resource_interface.h
+++ b/sdm/include/private/resource_interface.h
@@ -47,7 +47,7 @@
virtual DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst,
bool rotate90, bool ubwc_tiled,
bool use_rotator_downscale) = 0;
- virtual DisplayError ValidateCursorConfig(Handle display_ctx, const Layer &layer,
+ virtual DisplayError ValidateCursorConfig(Handle display_ctx, const Layer *layer,
bool is_top) = 0;
virtual DisplayError ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers,
int x, int y) = 0;
diff --git a/sdm/libs/core/comp_manager.cpp b/sdm/libs/core/comp_manager.cpp
index a7f137a..4bd73d4 100644
--- a/sdm/libs/core/comp_manager.cpp
+++ b/sdm/libs/core/comp_manager.cpp
@@ -219,7 +219,7 @@
// Avoid idle fallback, if there is only one app layer.
// TODO(user): App layer count will change for hybrid composition
- uint32_t app_layer_count = hw_layers->info.stack->layer_count - 1;
+ uint32_t app_layer_count = UINT32(hw_layers->info.stack->layers.size()) - 1;
if ((app_layer_count > 1 && display_comp_ctx->idle_fallback) || display_comp_ctx->fallback_) {
// Handle the idle timeout by falling back
constraints->safe_mode = true;
@@ -433,9 +433,9 @@
return supported;
}
- for (int32_t i = INT32(layer_stack->layer_count - 1); i >= 0; i--) {
- Layer &layer = layer_stack->layers[i];
- if (layer.composition == kCompositionGPUTarget) {
+ for (int32_t i = INT32(layer_stack->layers.size() - 1); i >= 0; i--) {
+ Layer *layer = layer_stack->layers.at(UINT32(i));
+ if (layer->composition == kCompositionGPUTarget) {
gpu_index = i;
break;
}
@@ -443,9 +443,9 @@
if (gpu_index <= 0) {
return supported;
}
- Layer &cursor_layer = layer_stack->layers[gpu_index - 1];
- if (cursor_layer.flags.cursor && resource_intf_->ValidateCursorConfig(display_resource_ctx,
- cursor_layer, true) == kErrorNone) {
+ Layer *cursor_layer = layer_stack->layers.at(UINT32(gpu_index) - 1);
+ if (cursor_layer->flags.cursor && resource_intf_->ValidateCursorConfig(display_resource_ctx,
+ cursor_layer, true) == kErrorNone) {
supported = true;
}
diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index c230674..33ee08d 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -28,6 +28,8 @@
#include <utils/formats.h>
#include <utils/rect.h>
+#include <vector>
+
#include "display_base.h"
#include "hw_info_interface.h"
@@ -124,18 +126,18 @@
DisplayError DisplayBase::ValidateGPUTarget(LayerStack *layer_stack) {
uint32_t i = 0;
- Layer *layers = layer_stack->layers;
+ std::vector<Layer *>layers = layer_stack->layers;
// TODO(user): Remove this check once we have query display attributes on virtual display
if (display_type_ == kVirtual) {
return kErrorNone;
}
-
- while (i < layer_stack->layer_count && (layers[i].composition != kCompositionGPUTarget)) {
+ uint32_t layer_count = UINT32(layers.size());
+ while ((i < layer_count) && (layers.at(i)->composition != kCompositionGPUTarget)) {
i++;
}
- if (i >= layer_stack->layer_count) {
+ if (i >= layer_count) {
DLOGE("Either layer count is zero or GPU target layer is not present");
return kErrorParameters;
}
@@ -143,20 +145,20 @@
uint32_t gpu_target_index = i;
// Check GPU target layer
- Layer &gpu_target_layer = layer_stack->layers[gpu_target_index];
+ Layer *gpu_target_layer = layers.at(gpu_target_index);
- if (!IsValid(gpu_target_layer.src_rect)) {
+ if (!IsValid(gpu_target_layer->src_rect)) {
DLOGE("Invalid src rect for GPU target layer");
return kErrorParameters;
}
- if (!IsValid(gpu_target_layer.dst_rect)) {
+ if (!IsValid(gpu_target_layer->dst_rect)) {
DLOGE("Invalid dst rect for GPU target layer");
return kErrorParameters;
}
- auto gpu_target_layer_dst_xpixels = gpu_target_layer.dst_rect.right;
- auto gpu_target_layer_dst_ypixels = gpu_target_layer.dst_rect.bottom;
+ auto gpu_target_layer_dst_xpixels = gpu_target_layer->dst_rect.right;
+ auto gpu_target_layer_dst_ypixels = gpu_target_layer->dst_rect.bottom;
HWDisplayAttributes display_attrib;
uint32_t active_index = 0;
@@ -594,13 +596,13 @@
for (uint32_t i = 0; i < num_hw_layers; 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;
+ Layer *layer = hw_layers_.info.stack->layers.at(layer_index);
+ LayerBuffer *input_buffer = layer->input_buffer;
HWLayerConfig &layer_config = hw_layers_.config[i];
HWRotatorSession &hw_rotator_session = layer_config.hw_rotator_session;
char idx[8] = { 0 };
- const char *comp_type = GetName(layer.composition);
+ const char *comp_type = GetName(layer->composition);
const char *buffer_format = GetFormatString(input_buffer->format);
const char *rotate_split[2] = { "Rot-1", "Rot-2" };
const char *comp_split[2] = { "Comp-1", "Comp-2" };
@@ -648,10 +650,10 @@
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(flags, sizeof(flags), "0x%08x", layer->flags.flags);
snprintf(decimation, sizeof(decimation), "%3d x %3d", pipe.horizontal_decimation,
pipe.vertical_decimation);
- snprintf(csc, sizeof(csc), "%d", layer.csc);
+ snprintf(csc, sizeof(csc), "%d", layer->csc);
DumpImpl::AppendString(buffer, length, format, idx, comp_type, comp_split[count],
"-", pipe.pipe_id, input_buffer->width, input_buffer->height,
diff --git a/sdm/libs/core/display_hdmi.cpp b/sdm/libs/core/display_hdmi.cpp
index 12ddd51..6522377 100644
--- a/sdm/libs/core/display_hdmi.cpp
+++ b/sdm/libs/core/display_hdmi.cpp
@@ -320,18 +320,18 @@
HWPanelInfo panel_info;
HWDisplayAttributes display_attributes;
uint32_t active_index = 0;
- uint32_t layer_count = layer_stack->layer_count;
+ uint32_t layer_count = UINT32(layer_stack->layers.size());
// S3D mode is supported for the following scenarios:
// 1. Layer stack containing only one s3d layer which is not skip
// 2. Layer stack containing only one secure layer along with one s3d layer
for (uint32_t i = 0; i < layer_count; i++) {
- Layer &layer = layer_stack->layers[i];
- LayerBuffer *layer_buffer = layer.input_buffer;
+ Layer *layer = layer_stack->layers.at(i);
+ LayerBuffer *layer_buffer = layer->input_buffer;
if (layer_buffer->s3d_format != kS3dFormatNone) {
s3d_layer_count++;
- if (s3d_layer_count > 1 || layer.flags.skip) {
+ if (s3d_layer_count > 1 || layer->flags.skip) {
s3d_mode = kS3DModeNone;
break;
}
diff --git a/sdm/libs/core/fb/hw_device.cpp b/sdm/libs/core/fb/hw_device.cpp
index c8b3f40..546490a 100644
--- a/sdm/libs/core/fb/hw_device.cpp
+++ b/sdm/libs/core/fb/hw_device.cpp
@@ -181,13 +181,13 @@
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
- Layer &layer = stack->layers[layer_index];
- LayerBuffer *input_buffer = layer.input_buffer;
+ Layer *layer = stack->layers.at(layer_index);
+ LayerBuffer *input_buffer = layer->input_buffer;
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;
bool is_rotator_used = (hw_rotator_session->hw_block_count != 0);
- bool is_cursor_pipe_used = (hw_layer_info.use_hw_cursor & layer.flags.cursor);
+ bool is_cursor_pipe_used = (hw_layer_info.use_hw_cursor & layer->flags.cursor);
for (uint32_t count = 0; count < 2; count++) {
HWPipeInfo *pipe_info = (count == 0) ? left_pipe : right_pipe;
@@ -206,7 +206,7 @@
mdp_buffer.comp_ratio.denom = 1000;
mdp_buffer.comp_ratio.numer = UINT32(hw_layers->config[i].compression * 1000);
- if (layer.flags.solid_fill) {
+ if (layer->flags.solid_fill) {
mdp_buffer.format = MDP_ARGB_8888;
} else {
error = SetFormat(input_buffer->format, &mdp_buffer.format);
@@ -214,10 +214,10 @@
return error;
}
}
- mdp_layer.alpha = layer.plane_alpha;
+ mdp_layer.alpha = layer->plane_alpha;
mdp_layer.z_order = UINT16(pipe_info->z_order);
mdp_layer.transp_mask = 0xffffffff;
- SetBlending(layer.blending, &mdp_layer.blend_op);
+ SetBlending(layer->blending, &mdp_layer.blend_op);
mdp_layer.pipe_ndx = pipe_info->pipe_id;
mdp_layer.horz_deci = pipe_info->horizontal_decimation;
mdp_layer.vert_deci = pipe_info->vertical_decimation;
@@ -225,7 +225,7 @@
SetRect(pipe_info->src_roi, &mdp_layer.src_rect);
SetRect(pipe_info->dst_roi, &mdp_layer.dst_rect);
SetMDPFlags(layer, is_rotator_used, is_cursor_pipe_used, &mdp_layer.flags);
- SetCSC(layer.csc, &mdp_layer.color_space);
+ SetCSC(layer->csc, &mdp_layer.color_space);
if (pipe_info->flags & kIGC) {
SetIGC(layer, mdp_layer_count);
}
@@ -235,7 +235,7 @@
mdp_layer.flags |= MDP_LAYER_MULTIRECT_PARALLEL_MODE;
}
}
- mdp_layer.bg_color = layer.solid_fill_color;
+ mdp_layer.bg_color = layer->solid_fill_color;
// HWScaleData to MDP driver
hw_scale_->SetHWScaleData(pipe_info->scale_data, mdp_layer_count, &mdp_layer);
@@ -331,7 +331,7 @@
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
- LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
+ LayerBuffer *input_buffer = stack->layers.at(layer_index)->input_buffer;
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;
@@ -424,7 +424,7 @@
for (uint32_t i = 0; i < hw_layer_info.count; i++) {
uint32_t layer_index = hw_layer_info.index[i];
- LayerBuffer *input_buffer = stack->layers[layer_index].input_buffer;
+ LayerBuffer *input_buffer = stack->layers.at(layer_index)->input_buffer;
HWRotatorSession *hw_rotator_session = &hw_layers->config[i].hw_rotator_session;
if (hw_rotator_session->hw_block_count) {
@@ -610,18 +610,18 @@
target->h = UINT32(source.bottom) - target->y;
}
-void HWDevice::SetMDPFlags(const Layer &layer, const bool &is_rotator_used,
+void HWDevice::SetMDPFlags(const Layer *layer, const bool &is_rotator_used,
bool is_cursor_pipe_used, uint32_t *mdp_flags) {
- LayerBuffer *input_buffer = layer.input_buffer;
+ const LayerBuffer *input_buffer = layer->input_buffer;
// Flips will be taken care by rotator, if layer uses rotator for downscale/rotation. So ignore
// flip flags for MDP.
if (!is_rotator_used) {
- if (layer.transform.flip_vertical) {
+ if (layer->transform.flip_vertical) {
*mdp_flags |= MDP_LAYER_FLIP_UD;
}
- if (layer.transform.flip_horizontal) {
+ if (layer->transform.flip_horizontal) {
*mdp_flags |= MDP_LAYER_FLIP_LR;
}
@@ -638,11 +638,11 @@
*mdp_flags |= MDP_LAYER_SECURE_DISPLAY_SESSION;
}
- if (layer.flags.solid_fill) {
+ if (layer->flags.solid_fill) {
*mdp_flags |= MDP_LAYER_SOLID_FILL;
}
- if (hw_panel_info_.mode != kModeCommand && layer.flags.cursor && is_cursor_pipe_used) {
+ if (hw_panel_info_.mode != kModeCommand && layer->flags.cursor && is_cursor_pipe_used) {
// command mode panels does not support async position update
*mdp_flags |= MDP_LAYER_ASYNC;
}
@@ -972,12 +972,12 @@
}
}
-void HWDevice::SetIGC(const Layer &layer, uint32_t index) {
+void HWDevice::SetIGC(const Layer *layer, uint32_t index) {
mdp_input_layer &mdp_layer = mdp_in_layers_[index];
mdp_overlay_pp_params &pp_params = pp_params_[index];
mdp_igc_lut_data_v1_7 &igc_lut_data = igc_lut_data_[index];
- switch (layer.igc) {
+ switch (layer->igc) {
case kIGCsRGB:
igc_lut_data.table_fmt = mdp_igc_srgb;
pp_params.igc_cfg.ops = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
diff --git a/sdm/libs/core/fb/hw_device.h b/sdm/libs/core/fb/hw_device.h
index d839c97..4a997a9 100644
--- a/sdm/libs/core/fb/hw_device.h
+++ b/sdm/libs/core/fb/hw_device.h
@@ -95,7 +95,7 @@
uint32_t width, uint32_t *target);
void SetBlending(const LayerBlending &source, mdss_mdp_blend_op *target);
void SetRect(const LayerRect &source, mdp_rect *target);
- void SetMDPFlags(const Layer &layer, const bool &is_rotator_used,
+ void SetMDPFlags(const Layer *layer, const bool &is_rotator_used,
bool is_cursor_pipe_used, uint32_t *mdp_flags);
// Retrieves HW FrameBuffer Node Index
int GetFBNodeIndex(HWDeviceType device_type);
@@ -110,8 +110,8 @@
int ParseLine(char *input, const char *delim, char *tokens[],
const uint32_t max_token, uint32_t *count);
void ResetDisplayParams();
- void SetCSC(LayerCSC source, mdp_color_space *color_space);
- void SetIGC(const Layer &layer, uint32_t index);
+ void SetCSC(const LayerCSC source, mdp_color_space *color_space);
+ void SetIGC(const Layer *layer, uint32_t index);
bool EnableHotPlugDetection(int enable);
ssize_t SysFsWrite(const char* file_node, const char* value, ssize_t length);
diff --git a/sdm/libs/core/resource_default.cpp b/sdm/libs/core/resource_default.cpp
index 8be809d..e13150b 100644
--- a/sdm/libs/core/resource_default.cpp
+++ b/sdm/libs/core/resource_default.cpp
@@ -199,9 +199,9 @@
return kErrorResources;
}
- Layer &layer = layer_info.stack->layers[layer_info.index[0]];
+ Layer *layer = layer_info.stack->layers.at(layer_info.index[0]);
- if (layer.composition != kCompositionGPUTarget) {
+ if (layer->composition != kCompositionGPUTarget) {
DLOGV_IF(kTagResources, "Not an FB layer");
return kErrorParameters;
}
@@ -499,7 +499,7 @@
HWLayers *hw_layers) {
HWLayersInfo &layer_info = hw_layers->info;
DisplayError error = kErrorNone;
- Layer& layer = layer_info.stack->layers[layer_info.index[0]];
+ Layer *layer = layer_info.stack->layers.at(layer_info.index[0]);
error = ValidateLayerParams(layer);
if (error != kErrorNone) {
@@ -510,15 +510,15 @@
HWPipeInfo &left_pipe = layer_config->left_pipe;
HWPipeInfo &right_pipe = layer_config->right_pipe;
- LayerRect src_rect = layer.src_rect;
- LayerRect dst_rect = layer.dst_rect;
+ LayerRect src_rect = layer->src_rect;
+ LayerRect dst_rect = layer->dst_rect;
error = ValidateDimensions(src_rect, dst_rect);
if (error != kErrorNone) {
return error;
}
- bool ubwc_tiled = IsUBWCFormat(layer.input_buffer->format);
+ bool ubwc_tiled = IsUBWCFormat(layer->input_buffer->format);
error = ValidateScaling(src_rect, dst_rect, false /*rotated90 */, ubwc_tiled,
false /* use_rotator_downscale */);
if (error != kErrorNone) {
@@ -544,8 +544,8 @@
left_pipe.z_order = 0;
DLOGV_IF(kTagResources, "==== FB layer Config ====");
- Log(kTagResources, "input layer src_rect", layer.src_rect);
- Log(kTagResources, "input layer dst_rect", layer.dst_rect);
+ Log(kTagResources, "input layer src_rect", layer->src_rect);
+ Log(kTagResources, "input layer dst_rect", layer->dst_rect);
Log(kTagResources, "cropped src_rect", src_rect);
Log(kTagResources, "cropped dst_rect", dst_rect);
Log(kTagResources, "left pipe src", layer_config->left_pipe.src_roi);
@@ -622,10 +622,10 @@
return false;
}
-DisplayError ResourceDefault::ValidateLayerParams(const Layer &layer) {
- const LayerRect &src = layer.src_rect;
- const LayerRect &dst = layer.dst_rect;
- LayerBuffer *input_buffer = layer.input_buffer;
+DisplayError ResourceDefault::ValidateLayerParams(const Layer *layer) {
+ const LayerRect &src = layer->src_rect;
+ const LayerRect &dst = layer->dst_rect;
+ const LayerBuffer *input_buffer = layer->input_buffer;
if (input_buffer->format == kFormatInvalid) {
DLOGV_IF(kTagResources, "Invalid input buffer format %d", input_buffer->format);
@@ -836,15 +836,15 @@
dst_right->right = dst_rect.right;
}
-DisplayError ResourceDefault::AlignPipeConfig(const Layer &layer, HWPipeInfo *left_pipe,
- HWPipeInfo *right_pipe) {
+DisplayError ResourceDefault::AlignPipeConfig(const Layer *layer, HWPipeInfo *left_pipe,
+ HWPipeInfo *right_pipe) {
DisplayError error = kErrorNone;
if (!left_pipe->valid) {
DLOGE_IF(kTagResources, "left_pipe should not be invalid");
return kErrorNotSupported;
}
- bool ubwc_tiled = IsUBWCFormat(layer.input_buffer->format);
+ bool ubwc_tiled = IsUBWCFormat(layer->input_buffer->format);
error = ValidatePipeParams(left_pipe, ubwc_tiled);
if (error != kErrorNone) {
goto PipeConfigExit;
@@ -883,7 +883,7 @@
return kErrorNone;
}
-DisplayError ResourceDefault::ValidateCursorConfig(Handle display_ctx, const Layer& layer,
+DisplayError ResourceDefault::ValidateCursorConfig(Handle display_ctx, const Layer *layer,
bool is_top) {
return kErrorNotSupported;
}
diff --git a/sdm/libs/core/resource_default.h b/sdm/libs/core/resource_default.h
index 23d7dfa..ce6dd5f 100644
--- a/sdm/libs/core/resource_default.h
+++ b/sdm/libs/core/resource_default.h
@@ -51,7 +51,7 @@
virtual DisplayError SetMaxMixerStages(Handle display_ctx, uint32_t max_mixer_stages);
virtual DisplayError ValidateScaling(const LayerRect &crop, const LayerRect &dst,
bool rotate90, bool ubwc_tiled, bool use_rotator_downscale);
- DisplayError ValidateCursorConfig(Handle display_ctx, const Layer& layer, bool is_top);
+ DisplayError ValidateCursorConfig(Handle display_ctx, const Layer *layer, bool is_top);
DisplayError ValidateCursorPosition(Handle display_ctx, HWLayers *hw_layers, int x, int y);
DisplayError SetMaxBandwidthMode(HWBwModes mode);
@@ -105,7 +105,7 @@
const LayerRect &src_rect, const LayerRect &dst_rect,
HWLayerConfig *layer_config);
bool CalculateCropRects(const LayerRect &scissor, LayerRect *crop, LayerRect *dst);
- DisplayError ValidateLayerParams(const Layer &layer);
+ DisplayError ValidateLayerParams(const Layer *layer);
DisplayError ValidateDimensions(const LayerRect &crop, const LayerRect &dst);
DisplayError ValidatePipeParams(HWPipeInfo *pipe_info, bool ubwc_tiled);
DisplayError ValidateDownScaling(float scale_x, float scale_y, bool ubwc_tiled);
@@ -115,7 +115,8 @@
DisplayError SetDecimationFactor(HWPipeInfo *pipe);
void SplitRect(const LayerRect &src_rect, const LayerRect &dst_rect, LayerRect *src_left,
LayerRect *dst_left, LayerRect *src_right, LayerRect *dst_right);
- DisplayError AlignPipeConfig(const Layer &layer, HWPipeInfo *left_pipe, HWPipeInfo *right_pipe);
+ DisplayError AlignPipeConfig(const Layer *layer, HWPipeInfo *left_pipe,
+ HWPipeInfo *right_pipe);
void ResourceStateLog(void);
DisplayError CalculateDecimation(float downscale, uint8_t *decimation);
DisplayError GetScaleLutConfig(HWScaleLutInfo *lut_info);
diff --git a/sdm/libs/core/strategy.cpp b/sdm/libs/core/strategy.cpp
index 924047a..0531693 100644
--- a/sdm/libs/core/strategy.cpp
+++ b/sdm/libs/core/strategy.cpp
@@ -78,14 +78,16 @@
uint32_t i = 0;
LayerStack *layer_stack = hw_layers_info_->stack;
- for (; i < layer_stack->layer_count; i++) {
- if (layer_stack->layers[i].composition == kCompositionGPUTarget) {
+ uint32_t layer_count = UINT32(layer_stack->layers.size());
+
+ for (; i < layer_count; i++) {
+ if (layer_stack->layers.at(i)->composition == kCompositionGPUTarget) {
fb_layer_index_ = i;
break;
}
}
- if (i == layer_stack->layer_count) {
+ if (i == layer_count) {
return kErrorUndefined;
}
@@ -136,11 +138,12 @@
uint32_t &hw_layer_count = hw_layers_info_->count;
hw_layer_count = 0;
- for (uint32_t i = 0; i < layer_stack->layer_count; i++) {
- LayerComposition &composition = layer_stack->layers[i].composition;
+ for (uint32_t i = 0; i < layer_stack->layers.size(); i++) {
+ Layer *layer = layer_stack->layers.at(i);
+ LayerComposition &composition = layer->composition;
if (composition == kCompositionGPUTarget) {
- hw_layers_info_->updated_src_rect[hw_layer_count] = layer_stack->layers[i].src_rect;
- hw_layers_info_->updated_dst_rect[hw_layer_count] = layer_stack->layers[i].dst_rect;
+ hw_layers_info_->updated_src_rect[hw_layer_count] = layer->src_rect;
+ hw_layers_info_->updated_dst_rect[hw_layer_count] = layer->dst_rect;
hw_layers_info_->index[hw_layer_count++] = i;
} else if (composition != kCompositionBlitTarget) {
composition = kCompositionGPU;
diff --git a/sdm/libs/hwc/blit_engine_c2d.cpp b/sdm/libs/hwc/blit_engine_c2d.cpp
index 2896f33..b55b06b 100644
--- a/sdm/libs/hwc/blit_engine_c2d.cpp
+++ b/sdm/libs/hwc/blit_engine_c2d.cpp
@@ -205,17 +205,18 @@
int fd = -1;
for (uint32_t i = blit_target_start_index_-2; (i > 0) && (count < num_blit_target_); i--) {
- Layer &layer = layer_stack->layers[i];
- LayerBuffer *layer_buffer = layer.input_buffer;
- if (layer.composition == kCompositionBlit) {
+ Layer *layer = layer_stack->layers.at(i);
+ LayerBuffer *layer_buffer = layer->input_buffer;
+ if (layer->composition == kCompositionBlit) {
int index = blit_target_start_index_ + count;
- layer_buffer->release_fence_fd = layer_stack->layers[index].input_buffer->release_fence_fd;
+ layer_buffer->release_fence_fd =
+ layer_stack->layers.at(index)->input_buffer->release_fence_fd;
fence_fd = layer_buffer->release_fence_fd;
close(layer_buffer->acquire_fence_fd);
layer_buffer->acquire_fence_fd = -1;
- layer_stack->layers[index].input_buffer->release_fence_fd = -1;
- fd = layer_stack->layers[index].input_buffer->acquire_fence_fd;
- layer_stack->layers[index].input_buffer->acquire_fence_fd = -1;
+ layer_stack->layers.at(index)->input_buffer->release_fence_fd = -1;
+ fd = layer_stack->layers.at(index)->input_buffer->acquire_fence_fd;
+ layer_stack->layers.at(index)->input_buffer->acquire_fence_fd = -1;
count++;
}
}
@@ -252,33 +253,34 @@
int BlitEngineC2d::Prepare(LayerStack *layer_stack) {
blit_target_start_index_ = 0;
- uint32_t gpu_target_index = layer_stack->layer_count-1;
- uint32_t i = INT(layer_stack->layer_count-1);
+ uint32_t layer_count = UINT32(layer_stack->layers.size());
+ uint32_t gpu_target_index = layer_count - 1; // default assumption
+ uint32_t i = 0;
- for (i = 0; i < layer_stack->layer_count; i++) {
- Layer &layer = layer_stack->layers[i];
+ for (; i < layer_count; i++) {
+ Layer *layer = layer_stack->layers.at(i);
// No 10 bit support for C2D
- if (Is10BitFormat(layer.input_buffer->format)) {
+ if (Is10BitFormat(layer->input_buffer->format)) {
return -1;
}
- if (layer.composition == kCompositionGPUTarget) {
+ if (layer->composition == kCompositionGPUTarget) {
// Need FBT size for allocating buffers
gpu_target_index = i;
break;
}
}
- if ((layer_stack->layer_count-1) == gpu_target_index) {
+ if ((layer_count - 1) == gpu_target_index) {
// No blit target layer
return -1;
}
blit_target_start_index_ = ++i;
- num_blit_target_ = layer_stack->layer_count - blit_target_start_index_;
+ num_blit_target_ = layer_count - blit_target_start_index_;
- LayerBuffer *layer_buffer = layer_stack->layers[gpu_target_index].input_buffer;
+ LayerBuffer *layer_buffer = layer_stack->layers.at(gpu_target_index)->input_buffer;
int fbwidth = INT(layer_buffer->width);
int fbheight = INT(layer_buffer->height);
if ((fbwidth < 0) || (fbheight < 0)) {
@@ -289,17 +291,17 @@
int k = blit_target_start_index_;
for (uint32_t j = 0; j < num_blit_target_; j++, k++) {
- Layer &layer = layer_stack->layers[k];
- LayerBuffer *layer_buffer = layer.input_buffer;
+ Layer *layer = layer_stack->layers.at(k);
+ LayerBuffer *layer_buffer = layer->input_buffer;
// Set the buffer height and width
layer_buffer->width = fbwidth;
layer_buffer->height = fbheight/3;
- layer.plane_alpha = 0xFF;
- layer.blending = kBlendingOpaque;
- layer.composition = kCompositionBlitTarget;
- layer.frame_rate = layer_stack->layers[gpu_target_index].frame_rate;
+ layer->plane_alpha = 0xFF;
+ layer->blending = kBlendingOpaque;
+ layer->composition = kCompositionBlitTarget;
+ layer->frame_rate = layer_stack->layers.at(gpu_target_index)->frame_rate;
}
return 0;
@@ -320,17 +322,17 @@
}
for (uint32_t i = num_app_layers-1; (i > 0) && (processed_blit < num_blit_target_); i--) {
- Layer &layer = layer_stack->layers[i];
- if (layer.composition != kCompositionBlit) {
+ Layer *layer = layer_stack->layers.at(i);
+ if (layer->composition != kCompositionBlit) {
continue;
}
blit_needed = true;
layer_stack->flags.attributes_changed = true;
- Layer &blit_layer = layer_stack->layers[blit_target_start_index_ + processed_blit];
- LayerRect &blit_src_rect = blit_layer.src_rect;
- int width = INT(layer.dst_rect.right - layer.dst_rect.left);
- int height = INT(layer.dst_rect.bottom - layer.dst_rect.top);
+ Layer *blit_layer = layer_stack->layers.at(blit_target_start_index_ + processed_blit);
+ LayerRect &blit_src_rect = blit_layer->src_rect;
+ int width = INT(layer->dst_rect.right - layer->dst_rect.left);
+ int height = INT(layer->dst_rect.bottom - layer->dst_rect.top);
usage = GRALLOC_USAGE_PRIVATE_IOMMU_HEAP | GRALLOC_USAGE_HW_TEXTURE;
if (blit_engine_c2d_->get(blit_engine_c2d_, COPYBIT_UBWC_SUPPORT) > 0) {
usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
@@ -345,9 +347,9 @@
// Left will be zero always
dst_rects[processed_blit].top = FLOAT(target_height - height);
dst_rects[processed_blit].right = dst_rects[processed_blit].left +
- (layer.dst_rect.right - layer.dst_rect.left);
+ (layer->dst_rect.right - layer->dst_rect.left);
dst_rects[processed_blit].bottom = (dst_rects[processed_blit].top +
- (layer.dst_rect.bottom - layer.dst_rect.top));
+ (layer->dst_rect.bottom - layer->dst_rect.top));
blit_src_rect = dst_rects[processed_blit];
processed_blit++;
}
@@ -361,19 +363,17 @@
if (blit_needed) {
for (uint32_t j = 0; j < num_blit_target_; j++) {
- Layer &layer = layer_stack->layers[j + content_list->numHwLayers];
+ Layer *layer = layer_stack->layers.at(j + content_list->numHwLayers);
private_handle_t *target_buffer = blit_target_buffer_[current_blit_target_index_];
// Set the fd information
- if (layer.input_buffer) {
- layer.input_buffer->width = target_width;
- layer.input_buffer->height = target_height;
- if (target_buffer->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
- layer.input_buffer->format = kFormatRGBA8888Ubwc;
- }
- layer.input_buffer->planes[0].fd = target_buffer->fd;
- layer.input_buffer->planes[0].offset = 0;
- layer.input_buffer->planes[0].stride = target_buffer->width;
+ layer->input_buffer->width = target_width;
+ layer->input_buffer->height = target_height;
+ if (target_buffer->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
+ layer->input_buffer->format = kFormatRGBA8888Ubwc;
}
+ layer->input_buffer->planes[0].fd = target_buffer->fd;
+ layer->input_buffer->planes[0].offset = 0;
+ layer->input_buffer->planes[0].stride = target_buffer->width;
}
}
@@ -394,8 +394,8 @@
// if not Blit Targets return
for (uint32_t i = 0; i < num_app_layers; i++) {
- Layer &layer = layer_stack->layers[i];
- if (layer.composition == kCompositionHybrid || layer.composition == kCompositionBlit) {
+ Layer *layer = layer_stack->layers.at(i);
+ if (layer->composition == kCompositionHybrid || layer->composition == kCompositionBlit) {
hybrid_present = true;
}
}
@@ -416,22 +416,22 @@
uint32_t processed_blit = 0;
for (uint32_t i = num_app_layers-1; (i > 0) && (processed_blit < num_blit_target_) &&
(status == 0); i--) {
- Layer &layer = layer_stack->layers[i];
- if (layer.composition != kCompositionBlit) {
+ Layer *layer = layer_stack->layers.at(i);
+ if (layer->composition != kCompositionBlit) {
continue;
}
for (uint32_t k = 0; k <= i; k++) {
- Layer &bottom_layer = layer_stack->layers[k];
- LayerBuffer *layer_buffer = bottom_layer.input_buffer;
+ Layer *bottom_layer = layer_stack->layers.at(k);
+ LayerBuffer *layer_buffer = bottom_layer->input_buffer;
// if layer below the blit layer does not intersect, ignore that layer
- LayerRect inter_sect = Intersection(layer.dst_rect, bottom_layer.dst_rect);
- if (bottom_layer.composition != kCompositionHybrid && !IsValid(inter_sect)) {
+ LayerRect inter_sect = Intersection(layer->dst_rect, bottom_layer->dst_rect);
+ if (bottom_layer->composition != kCompositionHybrid && !IsValid(inter_sect)) {
continue;
}
- if (bottom_layer.composition == kCompositionGPU ||
- bottom_layer.composition == kCompositionSDE ||
- bottom_layer.composition == kCompositionGPUTarget) {
+ if (bottom_layer->composition == kCompositionGPU ||
+ bottom_layer->composition == kCompositionSDE ||
+ bottom_layer->composition == kCompositionGPUTarget) {
continue;
}
@@ -444,10 +444,10 @@
layer_buffer->acquire_fence_fd = -1;
}
hwc_layer_1_t *hwc_layer = &content_list->hwLayers[k];
- LayerRect src_rect = bottom_layer.blit_regions.rect[processed_blit];
- Layer &blit_layer = layer_stack->layers[blit_target_start_index_ + processed_blit];
- LayerRect dest_rect = blit_layer.src_rect;
- int ret_val = DrawRectUsingCopybit(hwc_layer, &bottom_layer, src_rect, dest_rect);
+ LayerRect &src_rect = bottom_layer->blit_regions.at(processed_blit);
+ Layer *blit_layer = layer_stack->layers.at(blit_target_start_index_ + processed_blit);
+ LayerRect dest_rect = blit_layer->src_rect;
+ int ret_val = DrawRectUsingCopybit(hwc_layer, bottom_layer, src_rect, dest_rect);
copybit_layer_count++;
if (ret_val < 0) {
copybit_layer_count = 0;
@@ -469,9 +469,10 @@
DumpBlitTargetBuffer(fd);
// Set the fd to the LayerStack BlitTargets fd
- for (uint32_t k = blit_target_start_index_; k < layer_stack->layer_count; k++) {
- Layer &layer = layer_stack->layers[k];
- LayerBuffer *layer_buffer = layer.input_buffer;
+ uint32_t layer_count = UINT32(layer_stack->layers.size());
+ for (uint32_t k = blit_target_start_index_; k < layer_count; k++) {
+ Layer *layer = layer_stack->layers.at(k);
+ LayerBuffer *layer_buffer = layer->input_buffer;
layer_buffer->acquire_fence_fd = fd;
}
}
diff --git a/sdm/libs/hwc/hwc_display.cpp b/sdm/libs/hwc/hwc_display.cpp
index 3a40d22..ab9b4a7 100644
--- a/sdm/libs/hwc/hwc_display.cpp
+++ b/sdm/libs/hwc/hwc_display.cpp
@@ -52,18 +52,6 @@
namespace sdm {
-static void AssignLayerRegionsAddress(LayerRectArray *region, uint32_t rect_count,
- uint8_t **base_address) {
- if (rect_count) {
- region->rect = reinterpret_cast<LayerRect *>(*base_address);
- for (uint32_t i = 0; i < rect_count; i++) {
- region->rect[i] = LayerRect();
- }
- *base_address += rect_count * sizeof(LayerRect);
- }
- region->count = rect_count;
-}
-
static void ApplyDeInterlaceAdjustment(Layer *layer) {
// De-interlacing adjustment
if (layer->input_buffer->flags.interlace) {
@@ -137,11 +125,6 @@
return -EINVAL;
}
- if (layer_stack_memory_.raw) {
- delete[] layer_stack_memory_.raw;
- layer_stack_memory_.raw = NULL;
- }
-
delete framebuffer_config_;
if (blit_engine_) {
@@ -332,85 +315,27 @@
blit_target_count = kMaxBlitTargetLayers;
}
- // Allocate memory for
- // a) total number of layers
- // b) buffer handle for each layer
- // c) number of visible rectangles in each layer
- // d) number of dirty rectangles in each layer
- // e) number of blit rectangles in each layer
- size_t required_size = (num_hw_layers + blit_target_count) *
- (sizeof(Layer) + sizeof(LayerBuffer));
+ FreeLayerStack();
for (size_t i = 0; i < num_hw_layers + blit_target_count; i++) {
- uint32_t num_visible_rects = 0;
- uint32_t num_dirty_rects = 0;
-
- if (i < num_hw_layers) {
- hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
- num_visible_rects = UINT32(hwc_layer.visibleRegionScreen.numRects);
- num_dirty_rects = UINT32(hwc_layer.surfaceDamage.numRects);
- }
-
- // visible rectangles + dirty rectangles + blit rectangle
- size_t num_rects = num_visible_rects + num_dirty_rects + blit_target_count;
- required_size += num_rects * sizeof(LayerRect);
- }
-
- // Layer array may be large enough to hold current number of layers.
- // If not, re-allocate it now.
- if (layer_stack_memory_.size < required_size) {
- if (layer_stack_memory_.raw) {
- delete[] layer_stack_memory_.raw;
- layer_stack_memory_.size = 0;
- }
-
- // Allocate in multiple of kSizeSteps.
- required_size = ROUND_UP(required_size, layer_stack_memory_.kSizeSteps);
- layer_stack_memory_.raw = new uint8_t[required_size];
- if (!layer_stack_memory_.raw) {
- return -ENOMEM;
- }
-
- layer_stack_memory_.size = required_size;
- }
-
- // Assign memory addresses now.
- uint8_t *current_address = layer_stack_memory_.raw;
-
- // Layer array address
- layer_stack_ = LayerStack();
- layer_stack_.layers = reinterpret_cast<Layer *>(current_address);
- layer_stack_.layer_count = UINT32(num_hw_layers + blit_target_count);
- current_address += (num_hw_layers + blit_target_count) * sizeof(Layer);
-
- for (size_t i = 0; i < num_hw_layers + blit_target_count; i++) {
- uint32_t num_visible_rects = 0;
- uint32_t num_dirty_rects = 0;
-
- if (i < num_hw_layers) {
- hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
- num_visible_rects = UINT32(hwc_layer.visibleRegionScreen.numRects);
- num_dirty_rects = UINT32(hwc_layer.surfaceDamage.numRects);
- }
-
- Layer &layer = layer_stack_.layers[i];
- layer = Layer();
-
- // Layer buffer handle address
- layer.input_buffer = reinterpret_cast<LayerBuffer *>(current_address);
- *layer.input_buffer = LayerBuffer();
- current_address += sizeof(LayerBuffer);
-
- // Visible/Dirty/Blit rectangle address
- AssignLayerRegionsAddress(&layer.visible_regions, num_visible_rects, ¤t_address);
- AssignLayerRegionsAddress(&layer.dirty_regions, num_dirty_rects, ¤t_address);
- AssignLayerRegionsAddress(&layer.blit_regions, blit_target_count, ¤t_address);
+ Layer *layer = new Layer();
+ LayerBuffer *layer_buffer = new LayerBuffer();
+ layer->input_buffer = layer_buffer;
+ layer_stack_.layers.push_back(layer);
}
return 0;
}
-int HWCDisplay::PrepareLayerParams(hwc_layer_1_t *hwc_layer, Layer *layer) {
+void HWCDisplay::FreeLayerStack() {
+ for (Layer *layer : layer_stack_.layers) {
+ delete layer->input_buffer;
+ delete layer;
+ }
+ layer_stack_ = {};
+}
+
+int HWCDisplay::PrepareLayerParams(hwc_layer_1_t *hwc_layer, Layer* layer) {
const private_handle_t *pvt_handle = static_cast<const private_handle_t *>(hwc_layer->handle);
LayerBuffer *layer_buffer = layer->input_buffer;
@@ -510,41 +435,54 @@
for (size_t i = 0; i < num_hw_layers; i++) {
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
- Layer &layer = layer_stack_.layers[i];
-
- int ret = PrepareLayerParams(&content_list->hwLayers[i], &layer_stack_.layers[i]);
+ Layer *layer = layer_stack_.layers.at(i);
+ int ret = PrepareLayerParams(&content_list->hwLayers[i], layer);
if (ret != kErrorNone) {
return ret;
}
- layer.flags.skip = ((hwc_layer.flags & HWC_SKIP_LAYER) > 0);
- layer.flags.solid_fill = (hwc_layer.flags & kDimLayer) || solid_fill_enable_;
- if (layer.flags.skip || layer.flags.solid_fill) {
- layer.dirty_regions.count = 0;
+ layer->flags.skip = ((hwc_layer.flags & HWC_SKIP_LAYER) > 0);
+ layer->flags.solid_fill = (hwc_layer.flags & kDimLayer) || solid_fill_enable_;
+ if (layer->flags.skip || layer->flags.solid_fill) {
+ layer->dirty_regions.clear();
}
hwc_rect_t scaled_display_frame = hwc_layer.displayFrame;
ScaleDisplayFrame(&scaled_display_frame);
ApplyScanAdjustment(&scaled_display_frame);
- SetRect(scaled_display_frame, &layer.dst_rect);
- SetRect(hwc_layer.sourceCropf, &layer.src_rect);
- ApplyDeInterlaceAdjustment(&layer);
+ SetRect(scaled_display_frame, &layer->dst_rect);
+ SetRect(hwc_layer.sourceCropf, &layer->src_rect);
+ ApplyDeInterlaceAdjustment(layer);
- for (uint32_t j = 0; j < layer.visible_regions.count; j++) {
- SetRect(hwc_layer.visibleRegionScreen.rects[j], &layer.visible_regions.rect[j]);
- }
- for (uint32_t j = 0; j < layer.dirty_regions.count; j++) {
- SetRect(hwc_layer.surfaceDamage.rects[j], &layer.dirty_regions.rect[j]);
- }
- SetComposition(hwc_layer.compositionType, &layer.composition);
+ uint32_t num_visible_rects = UINT32(hwc_layer.visibleRegionScreen.numRects);
+ uint32_t num_dirty_rects = UINT32(hwc_layer.surfaceDamage.numRects);
+ for (uint32_t j = 0; j < num_visible_rects; j++) {
+ LayerRect visible_rect = {};
+ SetRect(hwc_layer.visibleRegionScreen.rects[j], &visible_rect);
+ layer->visible_regions.push_back(visible_rect);
+ }
+
+ for (uint32_t j = 0; j < num_dirty_rects; j++) {
+ LayerRect dirty_rect = {};
+ SetRect(hwc_layer.surfaceDamage.rects[j], &dirty_rect);
+ layer->dirty_regions.push_back(dirty_rect);
+ }
+
+ if (blit_engine_) {
+ for (uint32_t j = 0; j < kMaxBlitTargetLayers; j++) {
+ LayerRect blit_rect = {};
+ layer->blit_regions.push_back(blit_rect);
+ }
+ }
+
+ SetComposition(hwc_layer.compositionType, &layer->composition);
if (hwc_layer.compositionType != HWC_FRAMEBUFFER_TARGET) {
- display_rect_ = Union(display_rect_, layer.dst_rect);
+ display_rect_ = Union(display_rect_, layer->dst_rect);
}
-
// For dim layers, SurfaceFlinger
// - converts planeAlpha to per pixel alpha,
// - sets RGB color to 000,
@@ -555,12 +493,12 @@
// - incoming planeAlpha,
// - blending to Coverage.
if (hwc_layer.flags & kDimLayer) {
- layer.input_buffer->format = kFormatARGB8888;
- layer.solid_fill_color = 0xff000000;
- SetBlending(HWC_BLENDING_COVERAGE, &layer.blending);
+ layer->input_buffer->format = kFormatARGB8888;
+ layer->solid_fill_color = 0xff000000;
+ SetBlending(HWC_BLENDING_COVERAGE, &layer->blending);
} else {
- SetBlending(hwc_layer.blending, &layer.blending);
- LayerTransform &layer_transform = layer.transform;
+ SetBlending(hwc_layer.blending, &layer->blending);
+ LayerTransform &layer_transform = layer->transform;
uint32_t &hwc_transform = hwc_layer.transform;
layer_transform.flip_horizontal = ((hwc_transform & HWC_TRANSFORM_FLIP_H) > 0);
layer_transform.flip_vertical = ((hwc_transform & HWC_TRANSFORM_FLIP_V) > 0);
@@ -569,43 +507,43 @@
// TODO(user): Remove below block.
// For solid fill, only dest rect need to be specified.
- if (layer.flags.solid_fill) {
- LayerBuffer *input_buffer = layer.input_buffer;
- input_buffer->width = UINT32(layer.dst_rect.right - layer.dst_rect.left);
- input_buffer->height = UINT32(layer.dst_rect.bottom - layer.dst_rect.top);
- layer.src_rect.left = 0;
- layer.src_rect.top = 0;
- layer.src_rect.right = input_buffer->width;
- layer.src_rect.bottom = input_buffer->height;
+ if (layer->flags.solid_fill) {
+ LayerBuffer *input_buffer = layer->input_buffer;
+ input_buffer->width = UINT32(layer->dst_rect.right - layer->dst_rect.left);
+ input_buffer->height = UINT32(layer->dst_rect.bottom - layer->dst_rect.top);
+ layer->src_rect.left = 0;
+ layer->src_rect.top = 0;
+ layer->src_rect.right = input_buffer->width;
+ layer->src_rect.bottom = input_buffer->height;
}
- layer.plane_alpha = hwc_layer.planeAlpha;
- layer.flags.cursor = ((hwc_layer.flags & HWC_IS_CURSOR_LAYER) > 0);
- layer.flags.updating = true;
+ layer->plane_alpha = hwc_layer.planeAlpha;
+ layer->flags.cursor = ((hwc_layer.flags & HWC_IS_CURSOR_LAYER) > 0);
+ layer->flags.updating = true;
if (num_hw_layers <= kMaxLayerCount) {
- layer.flags.updating = IsLayerUpdating(content_list, INT32(i));
+ layer->flags.updating = IsLayerUpdating(content_list, INT32(i));
}
#ifdef QTI_BSP
if (hwc_layer.flags & HWC_SCREENSHOT_ANIMATOR_LAYER) {
layer_stack_.flags.animating = true;
}
#endif
- if (layer.flags.skip) {
+ if (layer->flags.skip) {
layer_stack_.flags.skip_present = true;
}
- if (layer.flags.cursor) {
+ if (layer->flags.cursor) {
layer_stack_.flags.cursor_present = true;
}
- if (layer.frame_rate > metadata_refresh_rate_) {
- metadata_refresh_rate_ = SanitizeRefreshRate(layer.frame_rate);
+ if (layer->frame_rate > metadata_refresh_rate_) {
+ metadata_refresh_rate_ = SanitizeRefreshRate(layer->frame_rate);
} else {
- layer.frame_rate = current_refresh_rate_;
+ layer->frame_rate = current_refresh_rate_;
}
- layer.input_buffer->buffer_id = reinterpret_cast<uint64_t>(hwc_layer.handle);
+ layer->input_buffer->buffer_id = reinterpret_cast<uint64_t>(hwc_layer.handle);
}
// Prepare the Blit Target
@@ -668,8 +606,8 @@
for (size_t i = 0; i < num_hw_layers; i++) {
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
- Layer &layer = layer_stack_.layers[i];
- LayerComposition composition = layer.composition;
+ Layer *layer = layer_stack_.layers.at(i);
+ LayerComposition composition = layer->composition;
if ((composition == kCompositionSDE) || (composition == kCompositionHybrid) ||
(composition == kCompositionBlit)) {
@@ -706,7 +644,7 @@
if (!flush_) {
for (size_t i = 0; i < num_hw_layers; i++) {
- CommitLayerParams(&content_list->hwLayers[i], &layer_stack_.layers[i]);
+ CommitLayerParams(&content_list->hwLayers[i], layer_stack_.layers.at(i));
}
if (use_blit_comp_) {
@@ -760,17 +698,17 @@
for (size_t i = 0; i < num_hw_layers; i++) {
hwc_layer_1_t &hwc_layer = content_list->hwLayers[i];
- Layer &layer = layer_stack_.layers[i];
- LayerBuffer *layer_buffer = layer_stack_.layers[i].input_buffer;
+ Layer *layer = layer_stack_.layers.at(i);
+ LayerBuffer *layer_buffer = layer->input_buffer;
if (!flush_) {
// If swapinterval property is set to 0 or for single buffer layers, do not update f/w
// release fences and discard fences from driver
- if (swap_interval_zero_ || layer.flags.single_buffer) {
+ if (swap_interval_zero_ || layer->flags.single_buffer) {
hwc_layer.releaseFenceFd = -1;
close(layer_buffer->release_fence_fd);
layer_buffer->release_fence_fd = -1;
- } else if (layer.composition != kCompositionGPU) {
+ } else if (layer->composition != kCompositionGPU) {
hwc_layer.releaseFenceFd = layer_buffer->release_fence_fd;
}
@@ -778,7 +716,7 @@
// framebuffer layer throughout animation and do not allow framework to do eglswapbuffer on
// framebuffer target. So graphics doesn't close the release fence fd of framebuffer target,
// Hence close the release fencefd of framebuffer target here.
- if (layer.composition == kCompositionGPUTarget && layer_stack_cache_.animating) {
+ if (layer->composition == kCompositionGPUTarget && layer_stack_cache_.animating) {
close(hwc_layer.releaseFenceFd);
hwc_layer.releaseFenceFd = -1;
}
@@ -813,7 +751,7 @@
bool HWCDisplay::NeedsFrameBufferRefresh(hwc_display_contents_1_t *content_list) {
- uint32_t layer_count = layer_stack_.layer_count;
+ uint32_t num_hw_layers = UINT32(content_list->numHwLayers);
// Handle ongoing animation and end here, start is handled below
if (layer_stack_cache_.animating) {
@@ -835,25 +773,25 @@
return true;
}
- for (uint32_t i = 0; i < layer_count; i++) {
- Layer &layer = layer_stack_.layers[i];
+ for (uint32_t i = 0; i < num_hw_layers; i++) {
+ Layer *layer = layer_stack_.layers.at(i);
LayerCache &layer_cache = layer_stack_cache_.layer_cache[i];
// need FB refresh for s3d case
- if (layer.input_buffer->s3d_format != kS3dFormatNone) {
+ if (layer->input_buffer->s3d_format != kS3dFormatNone) {
return true;
}
- if (layer.composition == kCompositionGPUTarget ||
- layer.composition == kCompositionBlitTarget) {
+ if (layer->composition == kCompositionGPUTarget ||
+ layer->composition == kCompositionBlitTarget) {
continue;
}
- if (layer_cache.composition != layer.composition) {
+ if (layer_cache.composition != layer->composition) {
return true;
}
- if ((layer.composition == kCompositionGPU) && IsLayerUpdating(content_list, INT32(i))) {
+ if ((layer->composition == kCompositionGPU) && IsLayerUpdating(content_list, INT32(i))) {
return true;
}
}
@@ -882,7 +820,7 @@
}
void HWCDisplay::CacheLayerStackInfo(hwc_display_contents_1_t *content_list) {
- uint32_t layer_count = layer_stack_.layer_count;
+ uint32_t layer_count = UINT32(layer_stack_.layers.size());
if (layer_count > kMaxLayerCount || layer_stack_.flags.animating) {
ResetLayerCacheStack();
@@ -890,16 +828,16 @@
}
for (uint32_t i = 0; i < layer_count; i++) {
- Layer &layer = layer_stack_.layers[i];
- if (layer.composition == kCompositionGPUTarget ||
- layer.composition == kCompositionBlitTarget) {
+ Layer *layer = layer_stack_.layers.at(i);
+ if (layer->composition == kCompositionGPUTarget ||
+ layer->composition == kCompositionBlitTarget) {
continue;
}
LayerCache &layer_cache = layer_stack_cache_.layer_cache[i];
layer_cache.handle = content_list->hwLayers[i].handle;
layer_cache.plane_alpha = content_list->hwLayers[i].planeAlpha;
- layer_cache.composition = layer.composition;
+ layer_cache.composition = layer->composition;
}
layer_stack_cache_.layer_count = layer_count;
@@ -1563,8 +1501,8 @@
uint32_t updating_count = 0;
for (uint i = 0; i < app_layer_count; i++) {
- Layer &layer = layer_stack_.layers[i];
- if (layer.flags.updating) {
+ Layer *layer = layer_stack_.layers.at(i);
+ if (layer->flags.updating) {
updating_count++;
}
}
diff --git a/sdm/libs/hwc/hwc_display.h b/sdm/libs/hwc/hwc_display.h
index 2960822..7b14f10 100644
--- a/sdm/libs/hwc/hwc_display.h
+++ b/sdm/libs/hwc/hwc_display.h
@@ -117,15 +117,6 @@
// Maximum number of layers supported by display manager.
static const uint32_t kMaxLayerCount = 32;
- // Structure to track memory allocation for layer stack (layers, rectangles) object.
- struct LayerStackMemory {
- static const size_t kSizeSteps = 4096; // Default memory allocation.
- uint8_t *raw; // Pointer to byte array.
- size_t size; // Current number of allocated bytes.
-
- LayerStackMemory() : raw(NULL), size(0) { }
- };
-
struct LayerCache {
buffer_handle_t handle;
uint8_t plane_alpha;
@@ -151,7 +142,8 @@
virtual DisplayError Refresh();
virtual DisplayError CECMessage(char *message);
- virtual int AllocateLayerStack(hwc_display_contents_1_t *content_list);
+ int AllocateLayerStack(hwc_display_contents_1_t *content_list);
+ void FreeLayerStack();
virtual int PrePrepareLayerStack(hwc_display_contents_1_t *content_list);
virtual int PrepareLayerStack(hwc_display_contents_1_t *content_list);
virtual int CommitLayerStack(hwc_display_contents_1_t *content_list);
@@ -190,7 +182,6 @@
int id_;
bool needs_blit_ = false;
DisplayInterface *display_intf_ = NULL;
- LayerStackMemory layer_stack_memory_;
LayerStack layer_stack_;
LayerStackCache layer_stack_cache_;
bool flush_on_error_ = false;
diff --git a/sdm/libs/hwc/hwc_display_virtual.cpp b/sdm/libs/hwc/hwc_display_virtual.cpp
index 0d3cdf2..ef7198c 100644
--- a/sdm/libs/hwc/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc/hwc_display_virtual.cpp
@@ -97,8 +97,7 @@
HWCDisplayVirtual::HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs)
: HWCDisplay(core_intf, hwc_procs, kVirtual, HWC_DISPLAY_VIRTUAL, false, NULL,
- DISPLAY_CLASS_VIRTUAL),
- dump_output_layer_(false), output_buffer_(NULL) {
+ DISPLAY_CLASS_VIRTUAL) {
}
int HWCDisplayVirtual::Init() {
@@ -120,6 +119,7 @@
if (output_buffer_) {
delete output_buffer_;
+ output_buffer_ = NULL;
}
return status;
diff --git a/sdm/libs/hwc/hwc_display_virtual.h b/sdm/libs/hwc/hwc_display_virtual.h
index 3a000c7..c383809 100644
--- a/sdm/libs/hwc/hwc_display_virtual.h
+++ b/sdm/libs/hwc/hwc_display_virtual.h
@@ -50,8 +50,8 @@
HWCDisplayVirtual(CoreInterface *core_intf, hwc_procs_t const **hwc_procs);
int SetOutputBuffer(hwc_display_contents_1_t *content_list);
- bool dump_output_layer_;
- LayerBuffer *output_buffer_;
+ bool dump_output_layer_ = false;
+ LayerBuffer *output_buffer_ = NULL;
};
inline bool HWCDisplayVirtual::IsValidContentList(hwc_display_contents_1_t *content_list) {
