diff --git a/libqdutils/qdMetaData.cpp b/libqdutils/qdMetaData.cpp
index 8f1e617..cd7727f 100644
--- a/libqdutils/qdMetaData.cpp
+++ b/libqdutils/qdMetaData.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2012-2017, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
@@ -145,8 +145,9 @@
 
 int getMetaData(private_handle_t *handle, DispFetchParamType paramType,
                                                     void *param) {
-    if (!handle) {
-        ALOGE("%s: Private handle is null!", __func__);
+    int ret = -1;
+    if (private_handle_t::validate(handle)) {
+        ALOGE("%s: Private handle is invalid! handle=%p", __func__, handle);
         return -1;
     }
     if (handle->fd_metadata == -1) {
@@ -158,6 +159,8 @@
         return -1;
     }
     unsigned long size = ROUND_UP_PAGESIZE(sizeof(MetaData_t));
+    // TODO: must be mmapped once and freed when the handle gets freed rather
+    // than mapping and un-mapping while getting each metadata field
     void *base = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED,
         handle->fd_metadata, 0);
     if (base == reinterpret_cast<void*>(MAP_FAILED)) {
@@ -168,41 +171,77 @@
     MetaData_t *data = reinterpret_cast <MetaData_t *>(base);
     switch (paramType) {
         case GET_PP_PARAM_INTERLACED:
-            *((int32_t *)param) = data->interlaced;
+            if (data->operation & PP_PARAM_INTERLACED) {
+                *((int32_t *)param) = data->interlaced;
+                ret = 0;
+            }
             break;
         case GET_BUFFER_GEOMETRY:
-            *((BufferDim_t *)param) = data->bufferDim;
+            if (data->operation & UPDATE_BUFFER_GEOMETRY) {
+                *((BufferDim_t *)param) = data->bufferDim;
+                ret = 0;
+            }
             break;
         case GET_REFRESH_RATE:
-            *((float *)param) = data->refreshrate;
+            if (data->operation & UPDATE_REFRESH_RATE) {
+                *((float *)param) = data->refreshrate;
+                ret = 0;
+            }
             break;
         case GET_COLOR_SPACE:
-            *((ColorSpace_t *)param) = data->colorSpace;
+            if (data->operation & UPDATE_COLOR_SPACE) {
+                *((ColorSpace_t *)param) = data->colorSpace;
+                ret = 0;
+            }
             break;
         case GET_MAP_SECURE_BUFFER:
-            *((int32_t *)param) = data->mapSecureBuffer;
+            if (data->operation & MAP_SECURE_BUFFER) {
+                *((int32_t *)param) = data->mapSecureBuffer;
+                ret = 0;
+            }
             break;
         case GET_S3D_FORMAT:
-            *((uint32_t *)param) = data->s3dFormat;
+            if (data->operation & S3D_FORMAT) {
+                *((uint32_t *)param) = data->s3dFormat;
+                ret = 0;
+            }
             break;
         case GET_LINEAR_FORMAT:
-            *((uint32_t *)param) = data->linearFormat;
+            if (data->operation & LINEAR_FORMAT) {
+                *((uint32_t *)param) = data->linearFormat;
+                ret = 0;
+            }
             break;
         case GET_IGC:
-            *((IGC_t *)param) = data->igc;
+            if (data->operation & SET_IGC) {
+                *((IGC_t *)param) = data->igc;
+                ret = 0;
+            }
             break;
         case GET_SINGLE_BUFFER_MODE:
-            *((uint32_t *)param) = data->isSingleBufferMode ;
+            if (data->operation & SET_SINGLE_BUFFER_MODE) {
+                *((uint32_t *)param) = data->isSingleBufferMode;
+                ret = 0;
+            }
             break;
         case GET_S3D_COMP:
-            *((S3DGpuComp_t *)param) = data->s3dComp;
+            if (data->operation & SET_S3D_COMP) {
+                *((S3DGpuComp_t *)param) = data->s3dComp;
+                ret = 0;
+            }
             break;
         case GET_VT_TIMESTAMP:
-            *((uint64_t *)param) = data->vtTimeStamp;
+            if (data->operation & SET_VT_TIMESTAMP) {
+                *((uint64_t *)param) = data->vtTimeStamp;
+                ret = 0;
+            }
             break;
 #ifdef USE_COLOR_METADATA
         case GET_COLOR_METADATA:
-            *((ColorMetaData *)param) = data->color;
+            if (data->operation & COLOR_METADATA) {
+                *((ColorMetaData *)param) = data->color;
+                ret = 0;
+            }
 #endif
             break;
         default:
@@ -212,7 +251,7 @@
     if(munmap(base, size))
         ALOGE("%s: failed to unmap ptr %p, err %d", __func__, (void*)base,
                                                                         errno);
-    return 0;
+    return ret;
 }
 
 int copyMetaData(struct private_handle_t *src, struct private_handle_t *dst) {
diff --git a/sdm/libs/hwc2/Android.mk b/sdm/libs/hwc2/Android.mk
index d4ff53c..c0d77ee 100644
--- a/sdm/libs/hwc2/Android.mk
+++ b/sdm/libs/hwc2/Android.mk
@@ -16,8 +16,8 @@
 LOCAL_CLANG                   := true
 
 LOCAL_SHARED_LIBRARIES        := libsdmcore libqservice libbinder libhardware libhardware_legacy \
-                                 libutils libcutils libsync libqdutils libdl \
-                                 libpowermanager libsdmutils libc++ liblog
+                                 libutils libcutils libsync libqdutils libqdMetaData libdl \
+                                 libpowermanager libsdmutils libc++ liblog libdrmutils
 
 ifneq ($(TARGET_USES_GRALLOC1), true)
     LOCAL_SHARED_LIBRARIES += libmemalloc
diff --git a/sdm/libs/hwc2/hwc_display_virtual.cpp b/sdm/libs/hwc2/hwc_display_virtual.cpp
index 11346ed..f77e9c9 100644
--- a/sdm/libs/hwc2/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc2/hwc_display_virtual.cpp
@@ -208,8 +208,7 @@
     output_buffer_->flags.secure = 0;
     output_buffer_->flags.video = 0;
 
-    const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(output_handle->base_metadata);
-    if (meta_data && SetCSC(meta_data, &output_buffer_->color_metadata) != kErrorNone) {
+    if (sdm::SetCSC(output_handle, &output_buffer_->color_metadata) != kErrorNone) {
       return HWC2::Error::BadParameter;
     }
 
diff --git a/sdm/libs/hwc2/hwc_layers.cpp b/sdm/libs/hwc2/hwc_layers.cpp
index 4345b30..91fb04b 100644
--- a/sdm/libs/hwc2/hwc_layers.cpp
+++ b/sdm/libs/hwc2/hwc_layers.cpp
@@ -17,6 +17,9 @@
  * limitations under the License.
  */
 
+#include <stdint.h>
+#include <qdMetaData.h>
+
 #include "hwc_layers.h"
 #ifndef USE_GRALLOC1
 #include <gr.h>
@@ -30,34 +33,34 @@
 
 std::atomic<hwc2_layer_t> HWCLayer::next_id_(1);
 
-DisplayError SetCSC(const MetaData_t *meta_data, ColorMetaData *color_metadata) {
-  if (meta_data->operation & COLOR_METADATA) {
-#ifdef USE_COLOR_METADATA
-    *color_metadata = meta_data->color;
-#endif
-  } else if (meta_data->operation & UPDATE_COLOR_SPACE) {
-    ColorSpace_t csc = meta_data->colorSpace;
-    color_metadata->range = Range_Limited;
+DisplayError SetCSC(const private_handle_t *pvt_handle, ColorMetaData *color_metadata) {
+  if (getMetaData(const_cast<private_handle_t *>(pvt_handle), GET_COLOR_METADATA,
+                  color_metadata) != 0) {
+    ColorSpace_t csc = ITU_R_601;
+    if (getMetaData(const_cast<private_handle_t *>(pvt_handle),  GET_COLOR_SPACE,
+                    &csc) == 0) {
+      if (csc == ITU_R_601_FR || csc == ITU_R_2020_FR) {
+        color_metadata->range = Range_Full;
+      }
 
-    if (csc == ITU_R_601_FR || csc == ITU_R_2020_FR) {
-      color_metadata->range = Range_Full;
-    }
-
-    switch (csc) {
-    case ITU_R_601:
-    case ITU_R_601_FR:
-      // video and display driver uses 601_525
-      color_metadata->colorPrimaries = ColorPrimaries_BT601_6_525;
-      break;
-    case ITU_R_709:
-      color_metadata->colorPrimaries = ColorPrimaries_BT709_5;
-      break;
-    case ITU_R_2020:
-    case ITU_R_2020_FR:
+      switch (csc) {
+      case ITU_R_601:
+      case ITU_R_601_FR:
+        // video and display driver uses 601_525
+        color_metadata->colorPrimaries = ColorPrimaries_BT601_6_525;
+        break;
+      case ITU_R_709:
+        color_metadata->colorPrimaries = ColorPrimaries_BT709_5;
+        break;
+      case ITU_R_2020:
+      case ITU_R_2020_FR:
         color_metadata->colorPrimaries = ColorPrimaries_BT2020;
         break;
-    default:
-      DLOGE("Unsupported CSC: %d", csc);
+      default:
+        DLOGE("Unsupported CSC: %d", csc);
+        return kErrorNotSupported;
+      }
+    } else {
       return kErrorNotSupported;
     }
   }
@@ -122,7 +125,7 @@
   layer_buffer->unaligned_height = UINT32(handle->unaligned_height);
 
   layer_buffer->format = GetSDMFormat(handle->format, handle->flags);
-  if (SetMetaData(handle, layer_) != kErrorNone) {
+  if (SetMetaData(const_cast<private_handle_t *>(handle), layer_) != kErrorNone) {
     return HWC2::Error::BadLayer;
   }
 
@@ -482,37 +485,37 @@
 }
 
 DisplayError HWCLayer::SetMetaData(const private_handle_t *pvt_handle, Layer *layer) {
-  const MetaData_t *meta_data = reinterpret_cast<MetaData_t *>(pvt_handle->base_metadata);
   LayerBuffer *layer_buffer = &layer->input_buffer;
-
-  if (!meta_data) {
-    return kErrorNone;
-  }
-
-  if (sdm::SetCSC(meta_data, &layer_buffer->color_metadata) != kErrorNone) {
+  if (sdm::SetCSC(pvt_handle, &layer_buffer->color_metadata) != kErrorNone) {
     return kErrorNotSupported;
   }
 
-  if (meta_data->operation & SET_IGC) {
-    if (SetIGC(meta_data->igc, &layer_buffer->igc) != kErrorNone) {
+  private_handle_t *handle = const_cast<private_handle_t *>(pvt_handle);
+  IGC_t igc = {};
+  if (getMetaData(handle, GET_IGC, &igc) == 0) {
+    if (SetIGC(igc, &layer_buffer->igc) != kErrorNone) {
       return kErrorNotSupported;
     }
   }
 
-  if (meta_data->operation & UPDATE_REFRESH_RATE) {
-    layer->frame_rate = RoundToStandardFPS(meta_data->refreshrate);
+  uint32_t fps = 0;
+  if (getMetaData(handle, GET_REFRESH_RATE  , &fps) == 0) {
+    layer->frame_rate = RoundToStandardFPS(fps);
   }
 
-  if ((meta_data->operation & PP_PARAM_INTERLACED) && meta_data->interlaced) {
-    layer_buffer->flags.interlace = true;
+  int32_t interlaced = 0;
+  if (getMetaData(handle, GET_PP_PARAM_INTERLACED, &interlaced) == 0) {
+    layer_buffer->flags.interlace = interlaced ? true : false;
   }
 
-  if (meta_data->operation & LINEAR_FORMAT) {
-    layer_buffer->format = GetSDMFormat(INT32(meta_data->linearFormat), 0);
+  uint32_t linear_format = 0;
+  if (getMetaData(handle, GET_LINEAR_FORMAT, &linear_format) == 0) {
+    layer_buffer->format = GetSDMFormat(INT32(linear_format), 0);
   }
 
-  if (meta_data->operation & S3D_FORMAT) {
-    layer_buffer->s3d_format = GetS3DFormat(meta_data->s3dFormat);
+  uint32_t s3d = 0;
+  if (getMetaData(handle, GET_S3D_FORMAT, &s3d) == 0) {
+    layer_buffer->s3d_format = GetS3DFormat(s3d);
   }
 
   return kErrorNone;
diff --git a/sdm/libs/hwc2/hwc_layers.h b/sdm/libs/hwc2/hwc_layers.h
index f9cb23e..58a45ae 100644
--- a/sdm/libs/hwc2/hwc_layers.h
+++ b/sdm/libs/hwc2/hwc_layers.h
@@ -39,7 +39,7 @@
 
 namespace sdm {
 
-DisplayError SetCSC(const MetaData_t *meta_data, ColorMetaData *color_metadata);
+DisplayError SetCSC(const private_handle_t *pvt_handle, ColorMetaData *color_metadata);
 
 enum GeometryChanges {
   kNone         = 0x000,
@@ -105,7 +105,6 @@
   LayerBufferFormat GetSDMFormat(const int32_t &source, const int flags);
   LayerBufferS3DFormat GetS3DFormat(uint32_t s3d_format);
   DisplayError SetMetaData(const private_handle_t *pvt_handle, Layer *layer);
-  DisplayError SetCSC(const MetaData_t *meta_data, ColorMetaData *color_metadata);
   DisplayError SetIGC(IGC_t source, LayerIGC *target);
   uint32_t RoundToStandardFPS(float fps);
 };