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, &current_address);
-    AssignLayerRegionsAddress(&layer.dirty_regions, num_dirty_rects, &current_address);
-    AssignLayerRegionsAddress(&layer.blit_regions, blit_target_count, &current_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) {