diff --git a/sdm/include/core/buffer_allocator.h b/sdm/include/core/buffer_allocator.h
index 0fd9388..1b47f79 100644
--- a/sdm/include/core/buffer_allocator.h
+++ b/sdm/include/core/buffer_allocator.h
@@ -61,7 +61,9 @@
 */
 struct AllocatedBufferInfo {
   int fd = -1;                   //!< Specifies the fd of the allocated buffer.
-  uint32_t stride = 0;           //!< Specifies aligned buffer width of the allocated buffer.
+  uint32_t stride = 0;           //!< Specifies allocated buffer stride in bytes.
+  uint32_t aligned_width = 0;    //!< Specifies aligned allocated buffer width in pixels.
+  uint32_t aligned_height = 0;   //!< Specifies aligned allocated buffer height in pixels.
   uint32_t size = 0;             //!< Specifies the size of the allocated buffer.
 };
 
diff --git a/sdm/include/core/layer_buffer.h b/sdm/include/core/layer_buffer.h
index 0bf1aa4..55318eb 100644
--- a/sdm/include/core/layer_buffer.h
+++ b/sdm/include/core/layer_buffer.h
@@ -222,8 +222,12 @@
   @sa LayerStack
 */
 struct LayerBuffer {
-  uint32_t width = 0;           //!< Actual width of the Layer that this buffer is for.
-  uint32_t height = 0;          //!< Actual height of the Layer that this buffer is for.
+  uint32_t width = 0;           //!< Aligned width of the Layer that this buffer is for.
+  uint32_t height = 0;          //!< Aligned height of the Layer that this buffer is for.
+  uint32_t unaligned_width = 0;
+                                //!< Unaligned width of the Layer that this buffer is for.
+  uint32_t unaligned_height = 0;
+                                //!< Unaligned 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.
   LayerCSC csc = kCSCFullRange601;                //!< Color Space of the layer.
diff --git a/sdm/include/utils/rect.h b/sdm/include/utils/rect.h
index d084556..6d3d482 100644
--- a/sdm/include/utils/rect.h
+++ b/sdm/include/utils/rect.h
@@ -55,8 +55,8 @@
                       bool flip_horizontal, LayerRect *out_rects);
   void SplitTopBottom(const LayerRect &in_rect, uint32_t split_count, uint32_t align_y,
                       bool flip_horizontal, LayerRect *out_rects);
-  void ScaleRect(const LayerRect &src_domain, const LayerRect &dst_domain, const LayerRect &in_rect,
-                 LayerRect *out_rect);
+  void MapRect(const LayerRect &src_domain, const LayerRect &dst_domain, const LayerRect &in_rect,
+               LayerRect *out_rect);
   RectOrientation GetOrientation(const LayerRect &in_rect);
 }  // namespace sdm
 
diff --git a/sdm/libs/core/display_base.cpp b/sdm/libs/core/display_base.cpp
index bd2d7d3..050167c 100644
--- a/sdm/libs/core/display_base.cpp
+++ b/sdm/libs/core/display_base.cpp
@@ -188,7 +188,7 @@
   LayerRect dst_domain = (LayerRect){0.0f, 0.0f, layer_mixer_width, layer_mixer_height};
   LayerRect out_rect = gpu_target_layer->dst_rect;
 
-  ScaleRect(src_domain, dst_domain, gpu_target_layer->dst_rect, &out_rect);
+  MapRect(src_domain, dst_domain, gpu_target_layer->dst_rect, &out_rect);
 
   auto gpu_target_layer_dst_xpixels = out_rect.right - out_rect.left;
   auto gpu_target_layer_dst_ypixels = out_rect.bottom - out_rect.top;
diff --git a/sdm/libs/hwc/blit_engine_c2d.cpp b/sdm/libs/hwc/blit_engine_c2d.cpp
index 3ead9b7..e5cf81c 100644
--- a/sdm/libs/hwc/blit_engine_c2d.cpp
+++ b/sdm/libs/hwc/blit_engine_c2d.cpp
@@ -282,8 +282,8 @@
   num_blit_target_ = layer_count - blit_target_start_index_;
 
   LayerBuffer *layer_buffer = layer_stack->layers.at(gpu_target_index)->input_buffer;
-  int fbwidth = INT(layer_buffer->width);
-  int fbheight = INT(layer_buffer->height);
+  int fbwidth = INT(layer_buffer->unaligned_width);
+  int fbheight = INT(layer_buffer->unaligned_height);
   if ((fbwidth < 0) || (fbheight < 0)) {
     return -1;
   }
@@ -294,10 +294,16 @@
   for (uint32_t j = 0; j < num_blit_target_; j++, k++) {
     Layer *layer = layer_stack->layers.at(k);
     LayerBuffer *layer_buffer = layer->input_buffer;
+    int aligned_w = 0;
+    int aligned_h = 0;
 
     // Set the buffer height and width
-    layer_buffer->width = fbwidth;
-    layer_buffer->height = fbheight/3;
+    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(fbwidth, fbheight/3,
+                   INT(HAL_PIXEL_FORMAT_RGBA_8888), 0, aligned_w, aligned_h);
+    layer_buffer->width = aligned_w;
+    layer_buffer->height = aligned_h;
+    layer_buffer->unaligned_width = fbwidth;
+    layer_buffer->unaligned_height = fbheight/3;
 
     layer->plane_alpha = 0xFF;
     layer->blending = kBlendingOpaque;
@@ -313,6 +319,8 @@
   uint32_t num_app_layers = (uint32_t) content_list->numHwLayers-1;
   int target_width = 0;
   int target_height = 0;
+  int target_aligned_width = 0;
+  int target_aligned_height = 0;
   uint32_t processed_blit = 0;
   LayerRect dst_rects[kMaxBlitTargetLayers];
   bool blit_needed = false;
@@ -334,19 +342,24 @@
     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);
+    int aligned_w = 0;
+    int aligned_h = 0;
     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;
     }
     // TODO(user): FrameBuffer is assumed to be RGBA
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width, height,
-                                 INT(HAL_PIXEL_FORMAT_RGBA_8888), usage, width, height);
-
     target_width = std::max(target_width, width);
     target_height += height;
 
+    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(width, height,
+                                 INT(HAL_PIXEL_FORMAT_RGBA_8888), usage, aligned_w, aligned_h);
+
+    target_aligned_width = std::max(target_aligned_width, aligned_w);
+    target_aligned_height += aligned_h;
+
     // Left will be zero always
-    dst_rects[processed_blit].top = FLOAT(target_height - height);
+    dst_rects[processed_blit].top = FLOAT(target_aligned_height - aligned_h);
     dst_rects[processed_blit].right = dst_rects[processed_blit].left +
                                       (layer->dst_rect.right - layer->dst_rect.left);
     dst_rects[processed_blit].bottom = (dst_rects[processed_blit].top +
@@ -367,8 +380,10 @@
       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
-        layer->input_buffer->width = target_width;
-        layer->input_buffer->height = target_height;
+        layer->input_buffer->width = target_aligned_width;
+        layer->input_buffer->height = target_aligned_height;
+        layer->input_buffer->unaligned_width = target_width;
+        layer->input_buffer->unaligned_height = target_height;
       if (target_buffer->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
           layer->input_buffer->format = kFormatRGBA8888Ubwc;
       }
diff --git a/sdm/libs/hwc/hwc_buffer_allocator.cpp b/sdm/libs/hwc/hwc_buffer_allocator.cpp
index 0092402..7873627 100644
--- a/sdm/libs/hwc/hwc_buffer_allocator.cpp
+++ b/sdm/libs/hwc/hwc_buffer_allocator.cpp
@@ -103,7 +103,10 @@
   }
 
   alloc_buffer_info->fd = data.fd;
+  // TODO(user): define stride for all planes and fix stride in bytes
   alloc_buffer_info->stride = UINT32(aligned_width);
+  alloc_buffer_info->aligned_width = UINT32(aligned_width);
+  alloc_buffer_info->aligned_height = UINT32(aligned_height);
   alloc_buffer_info->size = buffer_size;
 
   meta_buffer_info->base_addr = data.base;
@@ -138,6 +141,8 @@
 
     alloc_buffer_info->fd = -1;
     alloc_buffer_info->stride = 0;
+    alloc_buffer_info->aligned_width = 0;
+    alloc_buffer_info->aligned_height = 0;
     alloc_buffer_info->size = 0;
 
     meta_buffer_info->base_addr = NULL;
diff --git a/sdm/libs/hwc/hwc_display.cpp b/sdm/libs/hwc/hwc_display.cpp
index b40884e..3dafeb6 100644
--- a/sdm/libs/hwc/hwc_display.cpp
+++ b/sdm/libs/hwc/hwc_display.cpp
@@ -346,8 +346,18 @@
 
   if (pvt_handle) {
     layer_buffer->format = GetSDMFormat(pvt_handle->format, pvt_handle->flags);
-    layer_buffer->width = UINT32(pvt_handle->width);
-    layer_buffer->height = UINT32(pvt_handle->height);
+    int aligned_width, aligned_height;
+    int unaligned_width, unaligned_height;
+
+    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(pvt_handle, aligned_width,
+                                                          aligned_height);
+    AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(pvt_handle, unaligned_width,
+                                                            unaligned_height);
+
+    layer_buffer->width = UINT32(aligned_width);
+    layer_buffer->height = UINT32(aligned_height);
+    layer_buffer->unaligned_width = UINT32(unaligned_width);
+    layer_buffer->unaligned_height = UINT32(unaligned_height);
 
     if (SetMetaData(pvt_handle, layer) != kErrorNone) {
       return -EINVAL;
@@ -398,6 +408,8 @@
                                                             usage, aligned_width, aligned_height);
       layer_buffer->width = UINT32(aligned_width);
       layer_buffer->height = UINT32(aligned_height);
+      layer_buffer->unaligned_width = x_pixels;
+      layer_buffer->unaligned_height = y_pixels;
       layer_buffer->format = GetSDMFormat(format, flags);
     }
   }
@@ -522,6 +534,8 @@
       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);
+      input_buffer->unaligned_width = input_buffer->width;
+      input_buffer->unaligned_height = input_buffer->height;
       layer->src_rect.left = 0;
       layer->src_rect.top = 0;
       layer->src_rect.right = input_buffer->width;
@@ -1245,14 +1259,6 @@
     layer_buffer->format = GetSDMFormat(INT32(meta_data->linearFormat), 0);
   }
 
-  if (meta_data->operation & UPDATE_BUFFER_GEOMETRY) {
-    int actual_width = pvt_handle->width;
-    int actual_height = pvt_handle->height;
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(pvt_handle, actual_width, actual_height);
-    layer_buffer->width = UINT32(actual_width);
-    layer_buffer->height = UINT32(actual_height);
-  }
-
   if (meta_data->operation & SET_SINGLE_BUFFER_MODE) {
     layer->flags.single_buffer = meta_data->isSingleBufferMode;
     // Graphics can set this operation on all types of layers including FB and set the actual value
diff --git a/sdm/libs/hwc/hwc_display_primary.cpp b/sdm/libs/hwc/hwc_display_primary.cpp
index 50805d4..bf2d384 100644
--- a/sdm/libs/hwc/hwc_display_primary.cpp
+++ b/sdm/libs/hwc/hwc_display_primary.cpp
@@ -34,6 +34,7 @@
 #include <stdarg.h>
 #include <sys/mman.h>
 
+#include <gr.h>
 #include "hwc_display_primary.h"
 #include "hwc_debugger.h"
 
@@ -353,11 +354,16 @@
 }
 
 static void SetLayerBuffer(const BufferInfo& output_buffer_info, LayerBuffer *output_buffer) {
-  output_buffer->width = output_buffer_info.buffer_config.width;
-  output_buffer->height = output_buffer_info.buffer_config.height;
-  output_buffer->format = output_buffer_info.buffer_config.format;
-  output_buffer->planes[0].fd = output_buffer_info.alloc_buffer_info.fd;
-  output_buffer->planes[0].stride = output_buffer_info.alloc_buffer_info.stride;
+  const BufferConfig& buffer_config = output_buffer_info.buffer_config;
+  const AllocatedBufferInfo &alloc_buffer_info = output_buffer_info.alloc_buffer_info;
+
+  output_buffer->width = alloc_buffer_info.aligned_width;
+  output_buffer->height = alloc_buffer_info.aligned_height;
+  output_buffer->unaligned_width = buffer_config.width;
+  output_buffer->unaligned_height = buffer_config.height;
+  output_buffer->format = buffer_config.format;
+  output_buffer->planes[0].fd = alloc_buffer_info.fd;
+  output_buffer->planes[0].stride = alloc_buffer_info.stride;
 }
 
 void HWCDisplayPrimary::HandleFrameOutput() {
diff --git a/sdm/libs/hwc/hwc_display_virtual.cpp b/sdm/libs/hwc/hwc_display_virtual.cpp
index 25cd6fc..a4d343b 100644
--- a/sdm/libs/hwc/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc/hwc_display_virtual.cpp
@@ -277,12 +277,18 @@
       return -EINVAL;
     }
 
-    int output_buffer_width, output_buffer_height;
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(output_handle, output_buffer_width,
-                                                          output_buffer_height);
+    int aligned_width, aligned_height;
+    int unaligned_width, unaligned_height;
 
-    output_buffer_->width = UINT32(output_buffer_width);
-    output_buffer_->height = UINT32(output_buffer_height);
+    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(output_handle, aligned_width,
+                                                          aligned_height);
+    AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(output_handle, unaligned_width,
+                                                            unaligned_height);
+
+    output_buffer_->width = UINT32(aligned_width);
+    output_buffer_->height = UINT32(aligned_height);
+    output_buffer_->unaligned_width = UINT32(unaligned_width);
+    output_buffer_->unaligned_height = UINT32(unaligned_height);
     output_buffer_->flags.secure = 0;
     output_buffer_->flags.video = 0;
 
diff --git a/sdm/libs/hwc2/hwc_display.cpp b/sdm/libs/hwc2/hwc_display.cpp
index 772d2c7..d3e760d 100644
--- a/sdm/libs/hwc2/hwc_display.cpp
+++ b/sdm/libs/hwc2/hwc_display.cpp
@@ -1318,6 +1318,8 @@
   client_target_layer->input_buffer->format = GetSDMFormat(format, flags);
   client_target_layer->input_buffer->width = UINT32(aligned_width);
   client_target_layer->input_buffer->height = UINT32(aligned_height);
+  client_target_layer->input_buffer->unaligned_width = x_pixels;
+  client_target_layer->input_buffer->unaligned_height = y_pixels;
   client_target_layer->plane_alpha = 255;
 
   DLOGI("New framebuffer resolution (%dx%d)", fb_config.x_pixels, fb_config.y_pixels);
@@ -1472,6 +1474,8 @@
     LayerBuffer *layer_buffer = solid_fill_layer_->input_buffer;
     layer_buffer->width = primary_width;
     layer_buffer->height = primary_height;
+    layer_buffer->unaligned_width = primary_width;
+    layer_buffer->unaligned_height = primary_height;
     layer_buffer->acquire_fence_fd = -1;
     layer_buffer->release_fence_fd = -1;
 
diff --git a/sdm/libs/hwc2/hwc_display_primary.cpp b/sdm/libs/hwc2/hwc_display_primary.cpp
index 198eddb..a99a8b1 100644
--- a/sdm/libs/hwc2/hwc_display_primary.cpp
+++ b/sdm/libs/hwc2/hwc_display_primary.cpp
@@ -403,11 +403,16 @@
 }
 
 static void SetLayerBuffer(const BufferInfo &output_buffer_info, LayerBuffer *output_buffer) {
-  output_buffer->width = output_buffer_info.buffer_config.width;
-  output_buffer->height = output_buffer_info.buffer_config.height;
-  output_buffer->format = output_buffer_info.buffer_config.format;
-  output_buffer->planes[0].fd = output_buffer_info.alloc_buffer_info.fd;
-  output_buffer->planes[0].stride = output_buffer_info.alloc_buffer_info.stride;
+  const BufferConfig& buffer_config = output_buffer_info.buffer_config;
+  const AllocatedBufferInfo &alloc_buffer_info = output_buffer_info.alloc_buffer_info;
+
+  output_buffer->width = alloc_buffer_info.aligned_width;
+  output_buffer->height = alloc_buffer_info.aligned_height;
+  output_buffer->unaligned_width = buffer_config.width;
+  output_buffer->unaligned_height = buffer_config.height;
+  output_buffer->format = buffer_config.format;
+  output_buffer->planes[0].fd = alloc_buffer_info.fd;
+  output_buffer->planes[0].stride = alloc_buffer_info.stride;
 }
 
 void HWCDisplayPrimary::HandleFrameOutput() {
diff --git a/sdm/libs/hwc2/hwc_display_virtual.cpp b/sdm/libs/hwc2/hwc_display_virtual.cpp
index 787640c..5436faa 100644
--- a/sdm/libs/hwc2/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc2/hwc_display_virtual.cpp
@@ -188,12 +188,18 @@
       return HWC2::Error::BadParameter;
     }
 
-    int output_buffer_width, output_buffer_height;
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(output_handle, output_buffer_width,
-                                                          output_buffer_height);
+    int aligned_width, aligned_height;
+    int unaligned_width, unaligned_height;
 
-    output_buffer_->width = UINT32(output_buffer_width);
-    output_buffer_->height = UINT32(output_buffer_height);
+    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(output_handle, aligned_width,
+                                                          aligned_height);
+    AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(output_handle, unaligned_width,
+                                                            unaligned_height);
+
+    output_buffer_->width = UINT32(aligned_width);
+    output_buffer_->height = UINT32(aligned_height);
+    output_buffer_->unaligned_width = UINT32(unaligned_width);
+    output_buffer_->unaligned_height = UINT32(unaligned_height);
     // TODO(mkavm): Handle DRC and metadata changes
     output_buffer_->flags.secure = 0;
     output_buffer_->flags.video = 0;
diff --git a/sdm/libs/hwc2/hwc_layers.cpp b/sdm/libs/hwc2/hwc_layers.cpp
index a18cb4a..588ee8c 100644
--- a/sdm/libs/hwc2/hwc_layers.cpp
+++ b/sdm/libs/hwc2/hwc_layers.cpp
@@ -75,8 +75,18 @@
   }
 
   LayerBuffer *layer_buffer = layer_->input_buffer;
-  layer_buffer->width = UINT32(handle->width);
-  layer_buffer->height = UINT32(handle->height);
+  int aligned_width, aligned_height;
+  int unaligned_width, unaligned_height;
+
+  AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, aligned_width, aligned_height);
+  AdrenoMemInfo::getInstance().getUnalignedWidthAndHeight(handle, unaligned_width,
+                                                          unaligned_height);
+
+  layer_buffer->width = UINT32(aligned_width);
+  layer_buffer->height = UINT32(aligned_height);
+  layer_buffer->unaligned_width = UINT32(unaligned_width);
+  layer_buffer->unaligned_height = UINT32(unaligned_height);
+
   layer_buffer->format = GetSDMFormat(handle->format, handle->flags);
   if (SetMetaData(handle, layer_) != kErrorNone) {
     return HWC2::Error::BadLayer;
@@ -456,14 +466,6 @@
     layer_buffer->format = GetSDMFormat(INT32(meta_data->linearFormat), 0);
   }
 
-  if (meta_data->operation & UPDATE_BUFFER_GEOMETRY) {
-    int actual_width = pvt_handle->width;
-    int actual_height = pvt_handle->height;
-    AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(pvt_handle, actual_width, actual_height);
-    layer_buffer->width = UINT32(actual_width);
-    layer_buffer->height = UINT32(actual_height);
-  }
-
   if (meta_data->operation & S3D_FORMAT) {
     layer_buffer->s3d_format = GetS3DFormat(meta_data->s3dFormat);
   }
diff --git a/sdm/libs/utils/rect.cpp b/sdm/libs/utils/rect.cpp
index 3213b62..e1180e3 100644
--- a/sdm/libs/utils/rect.cpp
+++ b/sdm/libs/utils/rect.cpp
@@ -199,8 +199,8 @@
   }
 }
 
-void ScaleRect(const LayerRect &src_domain, const LayerRect &dst_domain, const LayerRect &in_rect,
-               LayerRect *out_rect) {
+void MapRect(const LayerRect &src_domain, const LayerRect &dst_domain, const LayerRect &in_rect,
+             LayerRect *out_rect) {
   if (!IsValid(src_domain) || !IsValid(dst_domain) || !IsValid(in_rect)) {
     return;
   }
@@ -213,10 +213,10 @@
   float width_ratio = dst_domain_width / src_domain_width;
   float height_ratio = dst_domain_height / src_domain_height;
 
-  out_rect->left = width_ratio * in_rect.left;
-  out_rect->top = height_ratio * in_rect.top;
-  out_rect->right = width_ratio * in_rect.right;
-  out_rect->bottom = height_ratio * in_rect.bottom;
+  out_rect->left = dst_domain.left + (width_ratio * in_rect.left);
+  out_rect->top = dst_domain.top + (height_ratio * in_rect.top);
+  out_rect->right = dst_domain.left + (width_ratio * in_rect.right);
+  out_rect->bottom = dst_domain.top + (height_ratio * in_rect.bottom);
 }
 
 RectOrientation GetOrientation(const LayerRect &in_rect) {