diff --git a/.clang-format b/.clang-format
index 9082c40..26ce4fe 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,6 +1,7 @@
 ---
 Language:        Cpp
 BasedOnStyle:  Google
+Standard : C++11
 AllowShortIfStatementsOnASingleLine: false
 AllowShortLoopsOnASingleLine: false
 AllowShortFunctionsOnASingleLine: Inline
diff --git a/Android.mk b/Android.mk
index a4d5687..a9b1175 100644
--- a/Android.mk
+++ b/Android.mk
@@ -7,7 +7,7 @@
                     $(sdm-libs)/hwc2 gpu_tonemapper libdrmutils libdisplayconfig
 endif
 
-display-hals += libgralloc1
+display-hals += gralloc
 
 ifeq ($(call is-vendor-board-platform,QCOM),true)
     include $(call all-named-subdir-makefiles,$(display-hals))
diff --git a/gpu_tonemapper/TonemapFactory.cpp b/gpu_tonemapper/TonemapFactory.cpp
index 3233682..db4b8be 100644
--- a/gpu_tonemapper/TonemapFactory.cpp
+++ b/gpu_tonemapper/TonemapFactory.cpp
@@ -18,7 +18,7 @@
  */
 
 #include "TonemapFactory.h"
-#include <utils/Log.h>
+#include <log/log.h>
 #include "Tonemapper.h"
 #include "engine.h"
 
diff --git a/gpu_tonemapper/glengine.cpp b/gpu_tonemapper/glengine.cpp
index 6c94c23..35e1932 100644
--- a/gpu_tonemapper/glengine.cpp
+++ b/gpu_tonemapper/glengine.cpp
@@ -18,7 +18,7 @@
  */
 
 #include "glengine.h"
-#include <utils/Log.h>
+#include <log/log.h>
 #include "engine.h"
 
 void checkGlError(const char *, int);
diff --git a/gralloc/Android.mk b/gralloc/Android.mk
new file mode 100644
index 0000000..31ff81d
--- /dev/null
+++ b/gralloc/Android.mk
@@ -0,0 +1,105 @@
+# Gralloc module
+LOCAL_PATH := $(call my-dir)
+include $(LOCAL_PATH)/../common.mk
+include $(CLEAR_VARS)
+
+LOCAL_MODULE                  := gralloc.$(TARGET_BOARD_PLATFORM)
+LOCAL_VENDOR_MODULE           := true
+LOCAL_MODULE_RELATIVE_PATH    := hw
+LOCAL_MODULE_TAGS             := optional
+LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
+
+LOCAL_HEADER_LIBRARIES        := display_headers
+LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdMetaData libsync libgrallocutils \
+                                 libgralloccore \
+                                 android.hardware.graphics.mapper@2.0
+LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wall -Werror
+LOCAL_CLANG                   := true
+LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
+LOCAL_SRC_FILES               := gr_device_impl.cpp
+LOCAL_COPY_HEADERS_TO         := $(common_header_export_path)
+LOCAL_COPY_HEADERS            := gr_device_impl.h gralloc_priv.h gr_priv_handle.h
+include $(BUILD_SHARED_LIBRARY)
+
+#libgrallocutils
+include $(CLEAR_VARS)
+LOCAL_MODULE                  := libgrallocutils
+LOCAL_VENDOR_MODULE           := true
+LOCAL_MODULE_TAGS             := optional
+LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
+LOCAL_HEADER_LIBRARIES        := display_headers
+LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdMetaData libdl  \
+                                  android.hardware.graphics.mapper@2.0
+LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wno-sign-conversion
+LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
+LOCAL_SRC_FILES               := gr_utils.cpp gr_adreno_info.cpp
+include $(BUILD_SHARED_LIBRARY)
+
+#libgralloccore
+include $(CLEAR_VARS)
+LOCAL_MODULE                  := libgralloccore
+LOCAL_VENDOR_MODULE           := true
+LOCAL_MODULE_TAGS             := optional
+LOCAL_C_INCLUDES              := $(common_includes) \
+                                 system/core/libion/include \
+                                 system/core/libion/kernel-headers \
+                                 $(kernel_includes)
+
+LOCAL_HEADER_LIBRARIES        := display_headers
+LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdMetaData libdl libgrallocutils libion \
+                                  android.hardware.graphics.mapper@2.0
+LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wno-sign-conversion
+LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
+LOCAL_SRC_FILES               := gr_allocator.cpp gr_buf_mgr.cpp gr_ion_alloc.cpp
+include $(BUILD_SHARED_LIBRARY)
+
+
+qti_mapper_version := $(shell \
+    if [ -d "$(TOP)/vendor/qcom/opensource/interfaces/display/mapper/1.0" ];\
+    then echo QTI_MAPPER_1_0; fi)
+
+qti_allocator_version := $(shell \
+    if [ -d "$(TOP)/vendor/qcom/opensource/interfaces/display/allocator/1.0" ];\
+    then echo QTI_ALLOCATOR_1_0; fi)
+
+
+#mapper
+include $(CLEAR_VARS)
+LOCAL_MODULE                  := android.hardware.graphics.mapper@2.0-impl-qti-display
+LOCAL_VENDOR_MODULE           := true
+LOCAL_MODULE_RELATIVE_PATH    := hw
+LOCAL_MODULE_TAGS             := optional
+LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
+LOCAL_HEADER_LIBRARIES        := display_headers
+LOCAL_SHARED_LIBRARIES        := $(common_libs) \
+                                  libhidlbase \
+                                  libhidltransport \
+                                  libqdMetaData \
+                                  libgrallocutils \
+                                  libgralloccore \
+                                  libsync \
+                                  android.hardware.graphics.mapper@2.0
+LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wno-sign-conversion
+LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
+LOCAL_SRC_FILES               := QtiMapper.cpp
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE                  := vendor.qti.hardware.display.allocator@1.0-service
+LOCAL_VENDOR_MODULE           := true
+LOCAL_MODULE_RELATIVE_PATH    := hw
+LOCAL_MODULE_TAGS             := optional
+LOCAL_HEADER_LIBRARIES        := display_headers
+LOCAL_SHARED_LIBRARIES        := $(common_libs) \
+                                 libhidlbase \
+                                 libhidltransport\
+                                 libqdMetaData \
+                                 libgrallocutils \
+                                 libgralloccore \
+                                 android.hardware.graphics.allocator@2.0
+LOCAL_CFLAGS                  := -DLOG_TAG=\"qdgralloc\" $(common_flags)
+LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps)
+LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
+LOCAL_SRC_FILES               := QtiAllocator.cpp service.cpp
+LOCAL_INIT_RC                 := vendor.qti.hardware.display.allocator@1.0-service.rc
+include $(BUILD_EXECUTABLE)
diff --git a/gralloc/QtiAllocator.cpp b/gralloc/QtiAllocator.cpp
new file mode 100644
index 0000000..c4d7aef
--- /dev/null
+++ b/gralloc/QtiAllocator.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright (c) 2018, 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
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation. nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define DEBUG 0
+#include "QtiAllocator.h"
+
+#include <log/log.h>
+#include <vector>
+
+#include "gr_utils.h"
+
+namespace vendor {
+namespace qti {
+namespace hardware {
+namespace display {
+namespace allocator {
+namespace V1_0 {
+namespace implementation {
+
+using android::hardware::hidl_handle;
+using gralloc::BufferDescriptor;
+
+QtiAllocator::QtiAllocator() {
+  buf_mgr_ = BufferManager::GetInstance();
+}
+
+// Methods from ::android::hardware::graphics::allocator::V2_0::IAllocator follow.
+Return<void> QtiAllocator::dumpDebugInfo(dumpDebugInfo_cb hidl_cb) {
+  std::ostringstream os;
+  buf_mgr_->Dump(&os);
+  hidl_string reply;
+  reply.setToExternal(os.str().c_str(), os.str().length());
+  hidl_cb(reply);
+  return Void();
+}
+
+Return<void> QtiAllocator::allocate(const hidl_vec<uint32_t> &descriptor, uint32_t count,
+                                    allocate_cb hidl_cb) {
+  ALOGD_IF(DEBUG, "Allocating buffers count: %d", count);
+  gralloc::BufferDescriptor desc;
+
+  auto err = desc.Decode(descriptor);
+  if (err != Error::NONE) {
+    hidl_cb(err, 0, hidl_vec<hidl_handle>());
+    return Void();
+  }
+
+  std::vector<hidl_handle> buffers;
+  buffers.reserve(count);
+  for (uint32_t i = 0; i < count; i++) {
+    buffer_handle_t buffer;
+    ALOGD_IF(DEBUG, "buffer: %p", &buffer);
+    err = buf_mgr_->AllocateBuffer(desc, &buffer);
+    if (err != Error::NONE) {
+      break;
+    }
+    buffers.emplace_back(hidl_handle(buffer));
+  }
+
+  uint32_t stride = 0;
+  hidl_vec<hidl_handle> hidl_buffers;
+  if (err == Error::NONE && buffers.size() > 0) {
+    stride = static_cast<uint32_t>(PRIV_HANDLE_CONST(buffers[0].getNativeHandle())->width);
+    hidl_buffers.setToExternal(buffers.data(), buffers.size());
+  }
+  hidl_cb(err, stride, hidl_buffers);
+
+  for (const auto &b : buffers) {
+    buf_mgr_->ReleaseBuffer(PRIV_HANDLE_CONST(b.getNativeHandle()));
+  }
+
+  return Void();
+}
+
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+IAllocator *HIDL_FETCH_IAllocator(const char * /* name */) {
+  return new QtiAllocator();
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace allocator
+}  // namespace display
+}  // namespace hardware
+}  // namespace qti
+}  // namespace vendor
diff --git a/gralloc/QtiAllocator.h b/gralloc/QtiAllocator.h
new file mode 100644
index 0000000..1e683e8
--- /dev/null
+++ b/gralloc/QtiAllocator.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2018, 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
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation. nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __QTIALLOCATOR_H__
+#define __QTIALLOCATOR_H__
+
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
+
+#include "gr_buf_mgr.h"
+
+namespace vendor {
+namespace qti {
+namespace hardware {
+namespace display {
+namespace allocator {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::graphics::allocator::V2_0::IAllocator;
+using ::android::hardware::graphics::mapper::V2_0::Error;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hidl::base::V1_0::DebugInfo;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::sp;
+using gralloc::BufferManager;
+
+class QtiAllocator : public IAllocator {
+ public:
+  QtiAllocator();
+  // Methods from ::android::hardware::graphics::allocator::V2_0::IAllocator follow.
+  Return<void> dumpDebugInfo(dumpDebugInfo_cb _hidl_cb) override;
+  Return<void> allocate(const hidl_vec<uint32_t> &descriptor, uint32_t count,
+                        allocate_cb _hidl_cb) override;
+
+  // Methods from ::android::hidl::base::V1_0::IBase follow.
+ private:
+  BufferManager *buf_mgr_ = nullptr;
+};
+
+extern "C" IAllocator *HIDL_FETCH_IAllocator(const char *name);
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace allocator
+}  // namespace display
+}  // namespace hardware
+}  // namespace qti
+}  // namespace vendor
+
+#endif  // __QTIALLOCATOR_H__
diff --git a/gralloc/QtiMapper.cpp b/gralloc/QtiMapper.cpp
new file mode 100644
index 0000000..8de28f5
--- /dev/null
+++ b/gralloc/QtiMapper.cpp
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2018, 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
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
+#define DEBUG 0
+#include "QtiMapper.h"
+#include <cutils/trace.h>
+#include <qdMetaData.h>
+#include <sync/sync.h>
+#include "gr_utils.h"
+
+namespace vendor {
+namespace qti {
+namespace hardware {
+namespace display {
+namespace mapper {
+namespace V1_0 {
+namespace implementation {
+
+using gralloc::BufferInfo;
+
+QtiMapper::QtiMapper() {
+  buf_mgr_ = BufferManager::GetInstance();
+  ALOGD_IF(DEBUG, "Created QtiMapper instance");
+}
+
+bool QtiMapper::ValidDescriptor(const IMapper::BufferDescriptorInfo &bd) {
+  if (bd.width == 0 || bd.height == 0 || (static_cast<int32_t>(bd.format) <= 0) ||
+      bd.layerCount != 1) {
+    return false;
+  }
+
+  return true;
+}
+
+// Methods from ::android::hardware::graphics::mapper::V2_0::IMapper follow.
+Return<void> QtiMapper::createDescriptor(const IMapper::BufferDescriptorInfo &descriptor_info,
+                                         createDescriptor_cb hidl_cb) {
+  ALOGD_IF(DEBUG,
+           "BufferDescriptorInfo: wxh: %dx%d usage: 0x%" PRIu64 " format: %d layer_count: %d",
+           descriptor_info.width, descriptor_info.height, descriptor_info.usage,
+           static_cast<uint32_t>(descriptor_info.format), descriptor_info.layerCount);
+
+  if (ValidDescriptor(descriptor_info)) {
+    auto vec = gralloc::BufferDescriptor::Encode(descriptor_info);
+    hidl_cb(Error::NONE, vec);
+  } else {
+    hidl_cb(Error::BAD_VALUE, hidl_vec<uint32_t>());
+  }
+  return Void();
+}
+
+Return<void> QtiMapper::importBuffer(const hidl_handle &raw_handle, importBuffer_cb hidl_cb) {
+  if (!raw_handle.getNativeHandle()) {
+    ALOGE("%s: Unable to import handle", __FUNCTION__);
+    hidl_cb(Error::BAD_BUFFER, nullptr);
+    return Void();
+  }
+
+  native_handle_t *buffer_handle = native_handle_clone(raw_handle.getNativeHandle());
+  if (!buffer_handle) {
+    ALOGE("%s: Unable to clone handle", __FUNCTION__);
+    hidl_cb(Error::NO_RESOURCES, nullptr);
+    return Void();
+  }
+
+  auto error = buf_mgr_->RetainBuffer(PRIV_HANDLE_CONST(buffer_handle));
+  if (error != Error::NONE) {
+    ALOGE("%s: Unable to retain handle: %p", __FUNCTION__, buffer_handle);
+    native_handle_close(buffer_handle);
+    native_handle_delete(buffer_handle);
+
+    hidl_cb(error, nullptr);
+    return Void();
+  }
+  ALOGD_IF(DEBUG, "Imported handle: %p id: %" PRIu64, buffer_handle,
+           PRIV_HANDLE_CONST(buffer_handle)->id);
+  hidl_cb(Error::NONE, buffer_handle);
+  return Void();
+}
+
+Return<Error> QtiMapper::freeBuffer(void *buffer) {
+  if (!buffer) {
+    return Error::BAD_BUFFER;
+  }
+  return buf_mgr_->ReleaseBuffer(PRIV_HANDLE_CONST(buffer));
+}
+
+bool QtiMapper::GetFenceFd(const hidl_handle &fence_handle, int *outFenceFd) {
+  auto handle = fence_handle.getNativeHandle();
+  if (handle && handle->numFds > 1) {
+    ALOGE("invalid fence handle with %d fds", handle->numFds);
+    return false;
+  }
+
+  *outFenceFd = (handle && handle->numFds == 1) ? handle->data[0] : -1;
+  return true;
+}
+
+void QtiMapper::WaitFenceFd(int fence_fd) {
+  if (fence_fd < 0) {
+    return;
+  }
+
+  const int timeout = 3000;
+  ATRACE_BEGIN("fence wait");
+  const int error = sync_wait(fence_fd, timeout);
+  ATRACE_END();
+  if (error < 0) {
+    ALOGE("QtiMapper: lock fence %d didn't signal in %u ms -  error: %s", fence_fd, timeout,
+          strerror(errno));
+  }
+}
+
+Error QtiMapper::LockBuffer(void *buffer, uint64_t usage, const hidl_handle &acquire_fence) {
+  if (!buffer) {
+    return Error::BAD_BUFFER;
+  }
+
+  int fence_fd;
+  if (!GetFenceFd(acquire_fence, &fence_fd)) {
+    return Error::BAD_VALUE;
+  }
+
+  if (fence_fd > 0) {
+    WaitFenceFd(fence_fd);
+  }
+
+  auto hnd = PRIV_HANDLE_CONST(buffer);
+
+  return buf_mgr_->LockBuffer(hnd, usage);
+}
+
+Return<void> QtiMapper::lock(void *buffer, uint64_t cpu_usage,
+                             const IMapper::Rect & /*access_region*/,
+                             const hidl_handle &acquire_fence, lock_cb hidl_cb) {
+  auto err = LockBuffer(buffer, cpu_usage, acquire_fence);
+  if (err != Error::NONE) {
+    hidl_cb(err, nullptr);
+    return Void();
+  }
+
+  auto hnd = PRIV_HANDLE_CONST(buffer);
+  auto *out_data = reinterpret_cast<void *>(hnd->base);
+  hidl_cb(Error::NONE, out_data);
+  return Void();
+}
+
+Return<void> QtiMapper::lockYCbCr(void *buffer, uint64_t cpu_usage,
+                                  const IMapper::Rect & /*access_region*/,
+                                  const hidl_handle &acquire_fence, lockYCbCr_cb hidl_cb) {
+  YCbCrLayout layout = {};
+  auto err = LockBuffer(buffer, cpu_usage, acquire_fence);
+  if (err != Error::NONE) {
+    hidl_cb(err, layout);
+    return Void();
+  }
+
+  auto hnd = PRIV_HANDLE_CONST(buffer);
+  android_ycbcr yuv_plane_info[2];
+  if (gralloc::GetYUVPlaneInfo(hnd, yuv_plane_info) != 0) {
+    hidl_cb(Error::BAD_VALUE, layout);
+  }
+  layout.y = yuv_plane_info[0].y;
+  layout.cr = yuv_plane_info[0].cr;
+  layout.cb = yuv_plane_info[0].cb;
+  layout.yStride = static_cast<uint32_t>(yuv_plane_info[0].ystride);
+  layout.cStride = static_cast<uint32_t>(yuv_plane_info[0].cstride);
+  layout.chromaStep = static_cast<uint32_t>(yuv_plane_info[0].chroma_step);
+  hidl_cb(Error::NONE, layout);
+  return Void();
+}
+
+Return<void> QtiMapper::unlock(void *buffer, unlock_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  if (buffer != nullptr) {
+    err = buf_mgr_->UnlockBuffer(PRIV_HANDLE_CONST(buffer));
+  }
+  // We don't have a release fence
+  hidl_cb(err, hidl_handle(nullptr));
+  return Void();
+}
+
+#ifdef ENABLE_QTI_MAPPER_EXTENSION
+Return<void> QtiMapper::getMapSecureBufferFlag(void *buffer, getMapSecureBufferFlag_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  int *map_secure_buffer = 0;
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    if (getMetaData(hnd, GET_MAP_SECURE_BUFFER, map_secure_buffer) != 0) {
+      *map_secure_buffer = 0;
+    } else {
+      err = Error::NONE;
+    }
+  }
+  hidl_cb(err, *map_secure_buffer != 0);
+  return Void();
+}
+
+Return<void> QtiMapper::getInterlacedFlag(void *buffer, getInterlacedFlag_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  int *interlaced_flag = nullptr;
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    if (getMetaData(hnd, GET_PP_PARAM_INTERLACED, interlaced_flag) != 0) {
+      *interlaced_flag = 0;
+    } else {
+      err = Error::NONE;
+    }
+  }
+  hidl_cb(err, *interlaced_flag != 0);
+  return Void();
+}
+
+Return<void> QtiMapper::getCustomDimensions(void *buffer, getCustomDimensions_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  int stride = 0;
+  int height = 0;
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    stride = hnd->width;
+    height = hnd->height;
+    gralloc::GetCustomDimensions(hnd, &stride, &height);
+    err = Error::NONE;
+  }
+  hidl_cb(err, stride, height);
+  return Void();
+}
+
+Return<void> QtiMapper::getRgbDataAddress(void *buffer, getRgbDataAddress_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  void *rgb_data = nullptr;
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    if (gralloc::GetRgbDataAddress(hnd, &rgb_data) == 0) {
+      err = Error::NONE;
+    }
+  }
+  hidl_cb(err, rgb_data);
+  return Void();
+}
+
+Return<void> QtiMapper::calculateBufferAttributes(int32_t width, int32_t height, int32_t format,
+                                                  uint64_t usage,
+                                                  calculateBufferAttributes_cb hidl_cb) {
+  unsigned int alignedw, alignedh;
+  BufferInfo info(width, height, format, usage);
+  gralloc::GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
+  bool ubwc_enabled = gralloc::IsUBwcEnabled(format, usage);
+  hidl_cb(Error::NONE, alignedw, alignedh, ubwc_enabled);
+  return Void();
+}
+
+Return<void> QtiMapper::getColorSpace(void *buffer, getColorSpace_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  int color_space = 0;
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    gralloc::GetColorSpaceFromMetadata(hnd, &color_space);
+    err = Error::NONE;
+  }
+  hidl_cb(err, color_space);
+  return Void();
+}
+
+Return<void> QtiMapper::getYuvPlaneInfo(void *buffer, getYuvPlaneInfo_cb hidl_cb) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  hidl_vec<YCbCrLayout> layout;
+  layout.resize(2);
+  android_ycbcr yuv_plane_info[2];
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    if (gralloc::GetYUVPlaneInfo(hnd, yuv_plane_info) == 0) {
+      err = Error::NONE;
+      for (int i=0; i < 2; i++) {
+        layout[i].y = yuv_plane_info[i].y;
+        layout[i].cr = yuv_plane_info[i].cr;
+        layout[i].cb = yuv_plane_info[i].cb;
+        layout[i].yStride = static_cast<uint32_t>(yuv_plane_info[i].ystride);
+        layout[i].cStride = static_cast<uint32_t>(yuv_plane_info[i].cstride);
+        layout[i].chromaStep = static_cast<uint32_t>(yuv_plane_info[i].chroma_step);
+      }
+    }
+  }
+  hidl_cb(err, layout);
+  return Void();
+}
+
+Return<Error> QtiMapper::setSingleBufferMode(void *buffer, bool enable) {
+  auto err = Error::BAD_BUFFER;
+  auto hnd = static_cast<private_handle_t *>(buffer);
+  if (buffer != nullptr && private_handle_t::validate(hnd) != 0) {
+    if (setMetaData(hnd, SET_SINGLE_BUFFER_MODE, &enable) != 0) {
+      err = Error::UNSUPPORTED;
+    } else {
+      err = Error::NONE;
+    }
+  }
+  return err;
+}
+#endif
+
+// Methods from ::android::hidl::base::V1_0::IBase follow.
+
+// When we are in passthrough mode, this method is used
+// by hidl to obtain the SP HAL object
+IMapper *HIDL_FETCH_IMapper(const char * /* name */) {
+  ALOGD_IF(DEBUG, "Fetching IMapper from QtiMapper");
+  auto mapper = new QtiMapper();
+  return static_cast<IMapper *>(mapper);
+}
+
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace mapper
+}  // namespace display
+}  // namespace hardware
+}  // namespace qti
+}  // namespace vendor
diff --git a/gralloc/QtiMapper.h b/gralloc/QtiMapper.h
new file mode 100644
index 0000000..218f074
--- /dev/null
+++ b/gralloc/QtiMapper.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2018, 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
+ * met:
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *     * Neither the name of The Linux Foundation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __QTIMAPPER_H__
+#define __QTIMAPPER_H__
+
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+#include "gr_buf_mgr.h"
+namespace vendor {
+namespace qti {
+namespace hardware {
+namespace display {
+namespace mapper {
+namespace V1_0 {
+namespace implementation {
+
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::graphics::mapper::V2_0::Error;
+using ::android::hardware::graphics::mapper::V2_0::IMapper;
+using ::android::hardware::graphics::mapper::V2_0::YCbCrLayout;
+using ::android::hardware::hidl_array;
+using ::android::hardware::hidl_handle;
+using ::android::hardware::hidl_memory;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hidl::base::V1_0::DebugInfo;
+using ::android::hidl::base::V1_0::IBase;
+using ::android::sp;
+using gralloc::BufferManager;
+
+class QtiMapper : public IMapper {
+ public:
+  QtiMapper();
+  // Methods from ::android::hardware::graphics::mapper::V2_0::IMapper follow.
+  Return<void> createDescriptor(const IMapper::BufferDescriptorInfo &descriptor_info,
+                                createDescriptor_cb hidl_cb) override;
+  Return<void> importBuffer(const hidl_handle &raw_handle, importBuffer_cb hidl_cb) override;
+  Return<Error> freeBuffer(void *buffer) override;
+  Return<void> lock(void *buffer, uint64_t cpu_usage, const IMapper::Rect &access_region,
+                    const hidl_handle &acquire_fence, lock_cb hidl_cb) override;
+  Return<void> lockYCbCr(void *buffer, uint64_t cpu_usage, const IMapper::Rect &access_region,
+                         const hidl_handle &acquire_fence, lockYCbCr_cb hidl_cb) override;
+  Return<void> unlock(void *buffer, unlock_cb hidl_cb) override;
+
+#ifdef ENABLE_QTI_MAPPER_EXTENSION
+  Return<void> getMapSecureBufferFlag(void *buffer, getMapSecureBufferFlag_cb _hidl_cb) override;
+  Return<void> getInterlacedFlag(void *buffer, getInterlacedFlag_cb _hidl_cb) override;
+  Return<void> getCustomDimensions(void *buffer, getCustomDimensions_cb _hidl_cb) override;
+  Return<void> getRgbDataAddress(void *buffer, getRgbDataAddress_cb _hidl_cb) override;
+  Return<void> calculateBufferAttributes(int32_t width, int32_t height, int32_t format,
+                                         uint64_t usage,
+                                         calculateBufferAttributes_cb _hidl_cb) override;
+  Return<void> getColorSpace(void *buffer, getColorSpace_cb _hidl_cb) override;
+  Return<void> getYuvPlaneInfo(void *buffer, getYuvPlaneInfo_cb _hidl_cb) override;
+  Return<Error> setSingleBufferMode(void *buffer, bool enable) override;
+#endif
+
+ private:
+  BufferManager *buf_mgr_ = nullptr;
+  bool ValidDescriptor(const IMapper::BufferDescriptorInfo &bd);
+  bool GetFenceFd(const hidl_handle &fence_handle, int *outFenceFd);
+  void WaitFenceFd(int fence_fd);
+  Error LockBuffer(void *buffer, uint64_t usage, const hidl_handle &acquire_fence);
+};
+
+extern "C" IMapper *HIDL_FETCH_IMapper(const char *name);
+}  // namespace implementation
+}  // namespace V1_0
+}  // namespace mapper
+}  // namespace display
+}  // namespace hardware
+}  // namespace qti
+}  // namespace vendor
+
+#endif  // __QTIMAPPER_H__
diff --git a/libgralloc1/gr_adreno_info.cpp b/gralloc/gr_adreno_info.cpp
similarity index 92%
rename from libgralloc1/gr_adreno_info.cpp
rename to gralloc/gr_adreno_info.cpp
index 8d83627..62b6d84 100644
--- a/libgralloc1/gr_adreno_info.cpp
+++ b/gralloc/gr_adreno_info.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2018, 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
@@ -27,19 +27,19 @@
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cutils/log.h>
+#include <log/log.h>
 #include <cutils/properties.h>
 #include <dlfcn.h>
 #include <mutex>
 
-#include "gralloc_priv.h"
 #include "gr_adreno_info.h"
 #include "gr_utils.h"
+#include "gralloc_priv.h"
 
 using std::lock_guard;
 using std::mutex;
 
-namespace gralloc1 {
+namespace gralloc {
 
 AdrenoMemInfo *AdrenoMemInfo::s_instance = nullptr;
 
@@ -130,9 +130,9 @@
     // num_samples is 1 always. We may  have to add uitility function to
     // find out these if there is a need to call this API for YUV formats.
     LINK_adreno_compute_fmt_aligned_width_and_height(
-        width, height, 0/*plane_id*/, GetGpuPixelFormat(format), 1/*num_samples*/,
-        tile_enabled, raster_mode, padding_threshold,
-        reinterpret_cast<int *>(aligned_w), reinterpret_cast<int *>(aligned_h));
+        width, height, 0 /*plane_id*/, GetGpuPixelFormat(format), 1 /*num_samples*/, tile_enabled,
+        raster_mode, padding_threshold, reinterpret_cast<int *>(aligned_w),
+        reinterpret_cast<int *>(aligned_h));
   } else if (LINK_adreno_compute_aligned_width_and_height) {
     LINK_adreno_compute_aligned_width_and_height(
         width, height, bpp, tile_enabled, raster_mode, padding_threshold,
@@ -192,10 +192,26 @@
       return ADRENO_PIXELFORMAT_R8G8B8A8;
     case HAL_PIXEL_FORMAT_RGBX_8888:
       return ADRENO_PIXELFORMAT_R8G8B8X8;
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+      return ADRENO_PIXELFORMAT_B8G8R8A8;
+    case HAL_PIXEL_FORMAT_RGB_888:
+      return ADRENO_PIXELFORMAT_R8G8B8;
     case HAL_PIXEL_FORMAT_RGB_565:
       return ADRENO_PIXELFORMAT_B5G6R5;
     case HAL_PIXEL_FORMAT_BGR_565:
       return ADRENO_PIXELFORMAT_R5G6B5;
+    case HAL_PIXEL_FORMAT_RGBA_5551:
+      return ADRENO_PIXELFORMAT_R5G5B5A1;
+    case HAL_PIXEL_FORMAT_RGBA_4444:
+      return ADRENO_PIXELFORMAT_R4G4B4A4;
+    case HAL_PIXEL_FORMAT_RGBA_1010102:
+       return ADRENO_PIXELFORMAT_R10G10B10A2_UNORM;
+    case HAL_PIXEL_FORMAT_RGBX_1010102:
+       return ADRENO_PIXELFORMAT_R10G10B10X2_UNORM;
+    case HAL_PIXEL_FORMAT_ABGR_2101010:
+       return ADRENO_PIXELFORMAT_A2B10G10R10_UNORM;
+    case HAL_PIXEL_FORMAT_RGBA_FP16:
+       return ADRENO_PIXELFORMAT_R16G16B16A16_FLOAT;
     case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
       return ADRENO_PIXELFORMAT_NV12;
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
@@ -207,14 +223,6 @@
     case HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC:
     case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
       return ADRENO_PIXELFORMAT_P010;
-    case HAL_PIXEL_FORMAT_RGBA_1010102:
-       return ADRENO_PIXELFORMAT_R10G10B10A2_UNORM;
-    case HAL_PIXEL_FORMAT_RGBX_1010102:
-       return ADRENO_PIXELFORMAT_R10G10B10X2_UNORM;
-    case HAL_PIXEL_FORMAT_ABGR_2101010:
-       return ADRENO_PIXELFORMAT_A2B10G10R10_UNORM;
-    case HAL_PIXEL_FORMAT_RGBA_FP16:
-       return ADRENO_PIXELFORMAT_R16G16B16A16_FLOAT;
     default:
       ALOGE("%s: No map for format: 0x%x", __FUNCTION__, hal_format);
       break;
@@ -223,4 +231,4 @@
   return ADRENO_PIXELFORMAT_UNKNOWN;
 }
 
-}  // namespace gralloc1
+}  // namespace gralloc
diff --git a/libgralloc1/gr_adreno_info.h b/gralloc/gr_adreno_info.h
similarity index 90%
rename from libgralloc1/gr_adreno_info.h
rename to gralloc/gr_adreno_info.h
index 83966ae..a454d15 100644
--- a/libgralloc1/gr_adreno_info.h
+++ b/gralloc/gr_adreno_info.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2018, 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
@@ -32,7 +32,7 @@
 
 #include <media/msm_media_info.h>
 
-namespace gralloc1 {
+namespace gralloc {
 
 // Adreno Pixel Formats
 typedef enum {
@@ -57,13 +57,13 @@
   ADRENO_PIXELFORMAT_R8G8B8X8_SRGB = 520,  //  GL_SRGB8
   ADRENO_PIXELFORMAT_R8G8B8_SRGB = 521,    //  GL_SRGB8
   ADRENO_PIXELFORMAT_A2B10G10R10_UNORM = 532,
-                                          // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
+  // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
   ADRENO_PIXELFORMAT_R10G10B10X2_UNORM = 537,
-                                          // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
-  ADRENO_PIXELFORMAT_R5G6B5 = 610,         //  RGBA version of B5G6R5
-  ADRENO_PIXELFORMAT_R5G5B5A1 = 611,       //  RGBA version of B5G5R5A1
-  ADRENO_PIXELFORMAT_R4G4B4A4 = 612,       //  RGBA version of B4G4R4A4
-  ADRENO_PIXELFORMAT_UYVY = 614,           //  YUV 4:2:2 packed progressive (1 plane)
+  // Vertex, Normalized GL_UNSIGNED_INT_10_10_10_2_OES
+  ADRENO_PIXELFORMAT_R5G6B5 = 610,    //  RGBA version of B5G6R5
+  ADRENO_PIXELFORMAT_R5G5B5A1 = 611,  //  RGBA version of B5G5R5A1
+  ADRENO_PIXELFORMAT_R4G4B4A4 = 612,  //  RGBA version of B4G4R4A4
+  ADRENO_PIXELFORMAT_UYVY = 614,      //  YUV 4:2:2 packed progressive (1 plane)
   ADRENO_PIXELFORMAT_NV21 = 619,
   ADRENO_PIXELFORMAT_Y8U8V8A8 = 620,  // YUV 4:4:4 packed (1 plane)
   ADRENO_PIXELFORMAT_Y8 = 625,        //  Single 8-bit luma only channel YUV format
@@ -149,6 +149,6 @@
   static AdrenoMemInfo *s_instance;
 };
 
-}  // namespace gralloc1
+}  // namespace gralloc
 
 #endif  // __GR_ADRENO_INFO_H__
diff --git a/libgralloc1/gr_allocator.cpp b/gralloc/gr_allocator.cpp
similarity index 71%
rename from libgralloc1/gr_allocator.cpp
rename to gralloc/gr_allocator.cpp
index 7a54187..970278e 100644
--- a/libgralloc1/gr_allocator.cpp
+++ b/gralloc/gr_allocator.cpp
@@ -27,12 +27,12 @@
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cutils/log.h>
+#include <log/log.h>
 #include <algorithm>
 #include <vector>
 
-#include "gr_utils.h"
 #include "gr_allocator.h"
+#include "gr_utils.h"
 #include "gralloc_priv.h"
 
 #include "qd_utils.h"
@@ -69,18 +69,17 @@
 #define ION_SC_PREVIEW_FLAGS ION_SECURE
 #endif
 
-using std::vector;
 using std::shared_ptr;
+using std::vector;
 
-namespace gralloc1 {
+namespace gralloc {
 
 static BufferInfo GetBufferInfo(const BufferDescriptor &descriptor) {
   return BufferInfo(descriptor.GetWidth(), descriptor.GetHeight(), descriptor.GetFormat(),
-                    descriptor.GetProducerUsage(), descriptor.GetConsumerUsage());
+                    descriptor.GetUsage());
 }
 
-Allocator::Allocator() : ion_allocator_(NULL) {
-}
+Allocator::Allocator() : ion_allocator_(nullptr) {}
 
 bool Allocator::Init() {
   ion_allocator_ = new IonAlloc();
@@ -97,14 +96,12 @@
   }
 }
 
-int Allocator::AllocateMem(AllocData *alloc_data, gralloc1_producer_usage_t prod_usage,
-                           gralloc1_consumer_usage_t cons_usage) {
+int Allocator::AllocateMem(AllocData *alloc_data, uint64_t usage) {
   int ret;
-  alloc_data->uncached = UseUncached(prod_usage, cons_usage);
+  alloc_data->uncached = UseUncached(usage);
 
   // After this point we should have the right heap set, there is no fallback
-  GetIonHeapInfo(prod_usage, cons_usage, &alloc_data->heap_id, &alloc_data->alloc_type,
-                 &alloc_data->flags);
+  GetIonHeapInfo(usage, &alloc_data->heap_id, &alloc_data->alloc_type, &alloc_data->flags);
 
   ret = ion_allocator_->AllocBuffer(alloc_data);
   if (ret >= 0) {
@@ -132,8 +129,7 @@
   return -EINVAL;
 }
 
-int Allocator::FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd,
-                          int handle) {
+int Allocator::FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd, int handle) {
   if (ion_allocator_) {
     return ion_allocator_->FreeBuffer(base, size, offset, fd, handle);
   }
@@ -151,7 +147,7 @@
 }
 
 bool Allocator::CheckForBufferSharing(uint32_t num_descriptors,
-                                      const vector<shared_ptr<BufferDescriptor>>& descriptors,
+                                      const vector<shared_ptr<BufferDescriptor>> &descriptors,
                                       ssize_t *max_index) {
   unsigned int cur_heap_id = 0, prev_heap_id = 0;
   unsigned int cur_alloc_type = 0, prev_alloc_type = 0;
@@ -163,10 +159,8 @@
   *max_index = -1;
   for (uint32_t i = 0; i < num_descriptors; i++) {
     // Check Cached vs non-cached and all the ION flags
-    cur_uncached = UseUncached(descriptors[i]->GetProducerUsage(),
-                               descriptors[i]->GetConsumerUsage());
-    GetIonHeapInfo(descriptors[i]->GetProducerUsage(), descriptors[i]->GetConsumerUsage(),
-                   &cur_heap_id, &cur_alloc_type, &cur_ion_flags);
+    cur_uncached = UseUncached(descriptors[i]->GetUsage());
+    GetIonHeapInfo(descriptors[i]->GetUsage(), &cur_heap_id, &cur_alloc_type, &cur_ion_flags);
 
     if (i > 0 && (cur_heap_id != prev_heap_id || cur_alloc_type != prev_alloc_type ||
                   cur_ion_flags != prev_ion_flags)) {
@@ -190,47 +184,46 @@
   return true;
 }
 
-int Allocator::GetImplDefinedFormat(gralloc1_producer_usage_t prod_usage,
-                                    gralloc1_consumer_usage_t cons_usage, int format) {
+int Allocator::GetImplDefinedFormat(uint64_t usage, int format) {
   int gr_format = format;
 
   // If input format is HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED then based on
   // the usage bits, gralloc assigns a format.
   if (format == HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED ||
       format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
-    if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC) {
+    if (usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
       // Use of 10BIT_TP and 10BIT bits is supposed to be mutually exclusive.
       // Each bit maps to only one format. Here we will check one of the bits
       // and ignore the other.
-      if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT_TP) {
+      if (usage & GRALLOC_USAGE_PRIVATE_10BIT_TP) {
         gr_format = HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC;
-      } else if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT) {
+      } else if (usage & GRALLOC_USAGE_PRIVATE_10BIT) {
         gr_format = HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC;
       } else {
         gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC;
       }
-    } else if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT) {
+    } else if (usage & GRALLOC_USAGE_PRIVATE_10BIT) {
       gr_format = HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS;
-    } else if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
-      if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_VIDEO_NV21_ENCODER) {
+    } else if (usage & BufferUsage::VIDEO_ENCODER) {
+      if (usage & GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER) {
         gr_format = HAL_PIXEL_FORMAT_NV21_ENCODEABLE;  // NV21
       } else {
         gr_format = HAL_PIXEL_FORMAT_NV12_ENCODEABLE;  // NV12
       }
-    } else if (cons_usage & GRALLOC1_CONSUMER_USAGE_CAMERA) {
-      if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
+    } else if (usage & BufferUsage::CAMERA_INPUT) {
+      if (usage & BufferUsage::CAMERA_OUTPUT) {
         // Assumed ZSL if both producer and consumer camera flags set
         gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;  // NV21
       } else {
         gr_format = HAL_PIXEL_FORMAT_YCrCb_420_SP;  // NV21
       }
-    } else if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
+    } else if (usage & BufferUsage::CAMERA_OUTPUT) {
       if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
         gr_format = HAL_PIXEL_FORMAT_NV21_ZSL;  // NV21
       } else {
         gr_format = HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS;  // NV12 preview
       }
-    } else if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
+    } else if (usage & BufferUsage::COMPOSER_OVERLAY) {
       // XXX: If we still haven't set a format, default to RGBA8888
       gr_format = HAL_PIXEL_FORMAT_RGBA_8888;
     } else if (format == HAL_PIXEL_FORMAT_YCbCr_420_888) {
@@ -246,50 +239,45 @@
 /* The default policy is to return cached buffers unless the client explicity
  * sets the PRIVATE_UNCACHED flag or indicates that the buffer will be rarely
  * read or written in software. */
-bool Allocator::UseUncached(gralloc1_producer_usage_t prod_usage,
-                            gralloc1_consumer_usage_t cons_usage) {
-  if ((prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_UNCACHED) ||
-      (prod_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED)) {
+bool Allocator::UseUncached(uint64_t usage) {
+  if ((usage & GRALLOC_USAGE_PRIVATE_UNCACHED) || (usage & BufferUsage::PROTECTED)) {
     return true;
   }
 
   // CPU read rarely
-  if ((prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_READ) &&
-      !(prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN)) {
+  if ((usage & BufferUsage::CPU_READ_MASK) == static_cast<uint64_t>(BufferUsage::CPU_READ_RARELY)) {
     return true;
   }
 
   // CPU  write rarely
-  if ((prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE) &&
-      !(prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN)) {
+  if ((usage & BufferUsage::CPU_WRITE_MASK) ==
+      static_cast<uint64_t>(BufferUsage::CPU_WRITE_RARELY)) {
     return true;
   }
 
-  if ((prod_usage & GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA) ||
-      (cons_usage & GRALLOC1_CONSUMER_USAGE_GPU_DATA_BUFFER)) {
+  if ((usage & BufferUsage::SENSOR_DIRECT_DATA) || (usage & BufferUsage::GPU_DATA_BUFFER)) {
     return true;
   }
 
   return false;
 }
 
-void Allocator::GetIonHeapInfo(gralloc1_producer_usage_t prod_usage,
-                               gralloc1_consumer_usage_t cons_usage, unsigned int *ion_heap_id,
-                               unsigned int *alloc_type, unsigned int *ion_flags) {
+void Allocator::GetIonHeapInfo(uint64_t usage, unsigned int *ion_heap_id, unsigned int *alloc_type,
+                               unsigned int *ion_flags) {
   unsigned int heap_id = 0;
   unsigned int type = 0;
   uint32_t flags = 0;
-  if (prod_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED) {
-    if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY) {
+  if (usage & GRALLOC_USAGE_PROTECTED) {
+    if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
       heap_id = ION_HEAP(SD_HEAP_ID);
       /*
        * There is currently no flag in ION for Secure Display
        * VM. Please add it to the define once available.
        */
       flags |= UINT(ION_SD_FLAGS);
-    } else if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
+    } else if (usage & BufferUsage::CAMERA_OUTPUT) {
       heap_id = ION_HEAP(SD_HEAP_ID);
-      if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
+      if (usage & BufferUsage::COMPOSER_OVERLAY) {
         flags |= UINT(ION_SC_PREVIEW_FLAGS);
       } else {
         flags |= UINT(ION_SC_FLAGS);
@@ -298,15 +286,9 @@
       heap_id = ION_HEAP(CP_HEAP_ID);
       flags |= UINT(ION_CP_FLAGS);
     }
-  } else if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_MM_HEAP) {
-    // MM Heap is exclusively a secure heap.
-    // If it is used for non secure cases, fallback to IOMMU heap
-    ALOGW("MM_HEAP cannot be used as an insecure heap. Using system heap instead!!");
-    heap_id |= ION_HEAP(ION_SYSTEM_HEAP_ID);
   }
 
-  if (prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ADSP_HEAP ||
-      prod_usage & GRALLOC1_PRODUCER_USAGE_SENSOR_DIRECT_DATA) {
+  if (usage & BufferUsage::SENSOR_DIRECT_DATA) {
     heap_id |= ION_HEAP(ION_ADSP_HEAP_ID);
   }
 
@@ -325,4 +307,4 @@
 
   return;
 }
-}  // namespace gralloc1
+}  // namespace gralloc
diff --git a/libgralloc1/gr_allocator.h b/gralloc/gr_allocator.h
similarity index 76%
rename from libgralloc1/gr_allocator.h
rename to gralloc/gr_allocator.h
index c059ba6..46ec09d 100644
--- a/libgralloc1/gr_allocator.h
+++ b/gralloc/gr_allocator.h
@@ -30,19 +30,14 @@
 #ifndef __GR_ALLOCATOR_H__
 #define __GR_ALLOCATOR_H__
 
-#ifdef MASTER_SIDE_CP
-#define SECURE_ALIGN SZ_4K
-#else
-#define SECURE_ALIGN SZ_1M
-#endif
-
 #include <vector>
 
-#include "gralloc_priv.h"
 #include "gr_buf_descriptor.h"
 #include "gr_ion_alloc.h"
+#include "gr_utils.h"
+#include "gralloc_priv.h"
 
-namespace gralloc1 {
+namespace gralloc {
 
 class Allocator {
  public:
@@ -53,23 +48,21 @@
   int ImportBuffer(int fd);
   int FreeBuffer(void *base, unsigned int size, unsigned int offset, int fd, int handle);
   int CleanBuffer(void *base, unsigned int size, unsigned int offset, int handle, int op, int fd);
-  int AllocateMem(AllocData *data, gralloc1_producer_usage_t prod_usage,
-                  gralloc1_consumer_usage_t cons_usage);
+  int AllocateMem(AllocData *data, uint64_t usage);
   // @return : index of the descriptor with maximum buffer size req
   bool CheckForBufferSharing(uint32_t num_descriptors,
-                             const std::vector<std::shared_ptr<BufferDescriptor>>& descriptors,
+                             const std::vector<std::shared_ptr<BufferDescriptor>> &descriptors,
                              ssize_t *max_index);
-  int GetImplDefinedFormat(gralloc1_producer_usage_t prod_usage,
-                           gralloc1_consumer_usage_t cons_usage, int format);
-  bool UseUncached(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage);
+  int GetImplDefinedFormat(uint64_t usage, int format);
+  bool UseUncached(uint64_t usage);
 
  private:
-  void GetIonHeapInfo(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage,
-                      unsigned int *ion_heap_id, unsigned int *alloc_type, unsigned int *ion_flags);
+  void GetIonHeapInfo(uint64_t usage, unsigned int *ion_heap_id, unsigned int *alloc_type,
+                      unsigned int *ion_flags);
 
   IonAlloc *ion_allocator_ = NULL;
 };
 
-}  // namespace gralloc1
+}  // namespace gralloc
 
 #endif  // __GR_ALLOCATOR_H__
diff --git a/gralloc/gr_buf_descriptor.h b/gralloc/gr_buf_descriptor.h
new file mode 100644
index 0000000..932db33
--- /dev/null
+++ b/gralloc/gr_buf_descriptor.h
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2016-2018, 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
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of The Linux Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __GR_BUF_DESCRIPTOR_H__
+#define __GR_BUF_DESCRIPTOR_H__
+
+#include <android/hardware/graphics/mapper/2.0/IMapper.h>
+#include <atomic>
+
+namespace gralloc {
+using android::hardware::graphics::mapper::V2_0::Error;
+using android::hardware::graphics::mapper::V2_0::IMapper;
+using android::hardware::hidl_vec;
+
+const uint32_t kBufferDescriptorSize = 7;
+const uint32_t kMagicVersion = 0x76312E30;  // v1.0
+
+class BufferDescriptor {
+ public:
+  BufferDescriptor() {}
+  explicit BufferDescriptor(uint64_t id) : id_(id) {}
+
+  static hidl_vec<uint32_t> Encode(const IMapper::BufferDescriptorInfo &bd_info) {
+    hidl_vec<uint32_t> out;
+    out.resize(kBufferDescriptorSize);
+    out[0] = kMagicVersion;
+    out[1] = bd_info.width;
+    out[2] = bd_info.height;
+    out[3] = bd_info.layerCount;
+    out[4] = static_cast<uint32_t>(bd_info.format);
+    out[5] = static_cast<uint32_t>(bd_info.usage);
+    out[6] = static_cast<uint32_t>(bd_info.usage >> 32);
+    return out;
+  }
+
+  Error Decode(const hidl_vec<uint32_t> &in) {
+    if (in.size() != kBufferDescriptorSize || in[0] != kMagicVersion) {
+      return Error::BAD_DESCRIPTOR;
+    }
+    width_ = static_cast<int32_t>(in[1]);
+    height_ = static_cast<int32_t>(in[2]);
+    layer_count_ = in[3];
+    format_ = static_cast<int32_t>(in[4]);
+    usage_ = static_cast<uint64_t>(in[6]) << 32 | in[5];
+    return Error::NONE;
+  }
+
+  void SetUsage(uint64_t usage) { usage_ |= usage; }
+
+  void SetDimensions(int w, int h) {
+    width_ = w;
+    height_ = h;
+  }
+
+  void SetColorFormat(int format) { format_ = format; }
+
+  void SetLayerCount(uint32_t layer_count) { layer_count_ = layer_count; }
+
+  uint64_t GetUsage() const { return usage_; }
+
+  int GetWidth() const { return width_; }
+
+  int GetHeight() const { return height_; }
+
+  int GetFormat() const { return format_; }
+
+  uint32_t GetLayerCount() const { return layer_count_; }
+
+  uint64_t GetId() const { return id_; }
+
+ private:
+  int width_ = -1;
+  int height_ = -1;
+  int format_ = -1;
+  uint32_t layer_count_ = 1;
+  uint64_t usage_ = 0;
+  const uint64_t id_ = 0;
+};
+};      // namespace gralloc
+#endif  // __GR_BUF_DESCRIPTOR_H__
diff --git a/gralloc/gr_buf_mgr.cpp b/gralloc/gr_buf_mgr.cpp
new file mode 100644
index 0000000..9f7b22e
--- /dev/null
+++ b/gralloc/gr_buf_mgr.cpp
@@ -0,0 +1,390 @@
+/*
+ * Copyright (c) 2011-2018 The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ *
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define DEBUG 0
+
+#include <iomanip>
+#include <sstream>
+#include <utility>
+#include <vector>
+
+#include "gr_buf_descriptor.h"
+#include "gr_buf_mgr.h"
+#include "gr_priv_handle.h"
+#include "qdMetaData.h"
+#include "qd_utils.h"
+
+namespace gralloc {
+
+static BufferInfo GetBufferInfo(const BufferDescriptor &descriptor) {
+  return BufferInfo(descriptor.GetWidth(), descriptor.GetHeight(), descriptor.GetFormat(),
+                    descriptor.GetUsage());
+}
+
+BufferManager::BufferManager() : next_id_(0) {
+  char property[PROPERTY_VALUE_MAX];
+
+  // Map framebuffer memory
+  if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
+      (!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
+       (!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
+    map_fb_mem_ = true;
+  }
+
+  handles_map_.clear();
+  allocator_ = new Allocator();
+  allocator_->Init();
+}
+
+BufferManager *BufferManager::GetInstance() {
+  static BufferManager *instance = new BufferManager();
+  return instance;
+}
+
+BufferManager::~BufferManager() {
+  if (allocator_) {
+    delete allocator_;
+  }
+}
+
+Error BufferManager::FreeBuffer(std::shared_ptr<Buffer> buf) {
+  auto hnd = buf->handle;
+  ALOGD_IF(DEBUG, "FreeBuffer handle:%p", hnd);
+
+  if (private_handle_t::validate(hnd) != 0) {
+    ALOGE("FreeBuffer: Invalid handle: %p", hnd);
+    return Error::BAD_BUFFER;
+  }
+
+  if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset, hnd->fd,
+                             buf->ion_handle_main) != 0) {
+    return Error::BAD_BUFFER;
+  }
+
+  unsigned int meta_size = ALIGN((unsigned int)sizeof(MetaData_t), PAGE_SIZE);
+  if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base_metadata), meta_size,
+                             hnd->offset_metadata, hnd->fd_metadata, buf->ion_handle_meta) != 0) {
+    return Error::BAD_BUFFER;
+  }
+
+  private_handle_t *handle = const_cast<private_handle_t *>(hnd);
+  handle->fd = -1;
+  handle->fd_metadata = -1;
+  if (!(handle->flags & private_handle_t::PRIV_FLAGS_CLIENT_ALLOCATED)) {
+    delete handle;
+  }
+  return Error::NONE;
+}
+
+void BufferManager::RegisterHandleLocked(const private_handle_t *hnd, int ion_handle,
+                                         int ion_handle_meta) {
+  auto buffer = std::make_shared<Buffer>(hnd, ion_handle, ion_handle_meta);
+  handles_map_.emplace(std::make_pair(hnd, buffer));
+}
+
+Error BufferManager::ImportHandleLocked(private_handle_t *hnd) {
+  ALOGD_IF(DEBUG, "Importing handle:%p id: %" PRIu64, hnd, hnd->id);
+  int ion_handle = allocator_->ImportBuffer(hnd->fd);
+  if (ion_handle < 0) {
+    ALOGE("Failed to import ion buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd, hnd->id);
+    return Error::BAD_BUFFER;
+  }
+  int ion_handle_meta = allocator_->ImportBuffer(hnd->fd_metadata);
+  if (ion_handle_meta < 0) {
+    ALOGE("Failed to import ion metadata buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd,
+          hnd->id);
+    return Error::BAD_BUFFER;
+  }
+  // Set base pointers to NULL since the data here was received over binder
+  hnd->base = 0;
+  hnd->base_metadata = 0;
+  RegisterHandleLocked(hnd, ion_handle, ion_handle_meta);
+  return Error::NONE;
+}
+
+std::shared_ptr<BufferManager::Buffer> BufferManager::GetBufferFromHandleLocked(
+    const private_handle_t *hnd) {
+  auto it = handles_map_.find(hnd);
+  if (it != handles_map_.end()) {
+    return it->second;
+  } else {
+    return nullptr;
+  }
+}
+
+Error BufferManager::MapBuffer(private_handle_t const *handle) {
+  private_handle_t *hnd = const_cast<private_handle_t *>(handle);
+  ALOGD_IF(DEBUG, "Map buffer handle:%p id: %" PRIu64, hnd, hnd->id);
+
+  hnd->base = 0;
+  if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base), hnd->size, hnd->offset,
+                            hnd->fd) != 0) {
+    return Error::BAD_BUFFER;
+  }
+  return Error::NONE;
+}
+
+Error BufferManager::RetainBuffer(private_handle_t const *hnd) {
+  ALOGD_IF(DEBUG, "Retain buffer handle:%p id: %" PRIu64, hnd, hnd->id);
+  auto err = Error::NONE;
+  std::lock_guard<std::mutex> lock(buffer_lock_);
+  auto buf = GetBufferFromHandleLocked(hnd);
+  if (buf != nullptr) {
+    buf->IncRef();
+  } else {
+    private_handle_t *handle = const_cast<private_handle_t *>(hnd);
+    err = ImportHandleLocked(handle);
+  }
+  return err;
+}
+
+Error BufferManager::ReleaseBuffer(private_handle_t const *hnd) {
+  ALOGD_IF(DEBUG, "Release buffer handle:%p", hnd);
+  std::lock_guard<std::mutex> lock(buffer_lock_);
+  auto buf = GetBufferFromHandleLocked(hnd);
+  if (buf == nullptr) {
+    ALOGE("Could not find handle: %p id: %" PRIu64, hnd, hnd->id);
+    return Error::BAD_BUFFER;
+  } else {
+    if (buf->DecRef()) {
+      handles_map_.erase(hnd);
+      // Unmap, close ion handle and close fd
+      FreeBuffer(buf);
+    }
+  }
+  return Error::NONE;
+}
+
+Error BufferManager::LockBuffer(const private_handle_t *hnd, uint64_t usage) {
+  std::lock_guard<std::mutex> lock(buffer_lock_);
+  auto err = Error::NONE;
+  ALOGD_IF(DEBUG, "LockBuffer buffer handle:%p id: %" PRIu64, hnd, hnd->id);
+
+  // If buffer is not meant for CPU return err
+  if (!CpuCanAccess(usage)) {
+    return Error::BAD_VALUE;
+  }
+
+  auto buf = GetBufferFromHandleLocked(hnd);
+  if (buf == nullptr) {
+    return Error::BAD_BUFFER;
+  }
+
+  if (hnd->base == 0) {
+    // we need to map for real
+    err = MapBuffer(hnd);
+  }
+
+  // Invalidate if CPU reads in software and there are non-CPU
+  // writers. No need to do this for the metadata buffer as it is
+  // only read/written in software.
+
+  // todo use handle here
+  if (err == Error::NONE && (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) &&
+      (hnd->flags & private_handle_t::PRIV_FLAGS_CACHED)) {
+    if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
+                                buf->ion_handle_main, CACHE_INVALIDATE, hnd->fd)) {
+      return Error::BAD_BUFFER;
+    }
+  }
+
+  // Mark the buffer to be flushed after CPU write.
+  if (err == Error::NONE && CpuCanWrite(usage)) {
+    private_handle_t *handle = const_cast<private_handle_t *>(hnd);
+    handle->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
+  }
+
+  return err;
+}
+
+Error BufferManager::UnlockBuffer(const private_handle_t *handle) {
+  std::lock_guard<std::mutex> lock(buffer_lock_);
+  auto status = Error::NONE;
+
+  private_handle_t *hnd = const_cast<private_handle_t *>(handle);
+  auto buf = GetBufferFromHandleLocked(hnd);
+  if (buf == nullptr) {
+    return Error::BAD_BUFFER;
+  }
+
+  if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) {
+    if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
+                                buf->ion_handle_main, CACHE_CLEAN, hnd->fd) != 0) {
+      status = Error::BAD_BUFFER;
+    }
+    hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
+  }
+
+  return status;
+}
+
+int BufferManager::GetHandleFlags(int format, uint64_t usage) {
+  int flags = 0;
+  if (usage & BufferUsage::VIDEO_ENCODER) {
+    flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
+  }
+
+  if (usage & BufferUsage::CAMERA_OUTPUT) {
+    flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
+  }
+
+  if (usage & BufferUsage::CAMERA_INPUT) {
+    flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
+  }
+
+  if (usage & BufferUsage::COMPOSER_OVERLAY) {
+    flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
+  }
+
+  if (usage & BufferUsage::GPU_TEXTURE) {
+    flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
+  }
+
+  if (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY) {
+    flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
+  }
+
+  if (IsUBwcEnabled(format, usage)) {
+    flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
+  }
+
+  if (usage & (BufferUsage::CPU_READ_MASK | BufferUsage::CPU_WRITE_MASK)) {
+    flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
+  }
+
+  if ((usage & (BufferUsage::VIDEO_ENCODER | BufferUsage::VIDEO_DECODER |
+                BufferUsage::CAMERA_OUTPUT | BufferUsage::GPU_RENDER_TARGET))) {
+    flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
+  }
+
+  if (!allocator_->UseUncached(usage)) {
+    flags |= private_handle_t::PRIV_FLAGS_CACHED;
+  }
+
+  return flags;
+}
+
+int BufferManager::GetBufferType(int inputFormat) {
+  int buffer_type = BUFFER_TYPE_VIDEO;
+  if (IsUncompressedRGBFormat(inputFormat)) {
+    // RGB formats
+    buffer_type = BUFFER_TYPE_UI;
+  }
+
+  return buffer_type;
+}
+
+Error BufferManager::AllocateBuffer(const BufferDescriptor &descriptor, buffer_handle_t *handle,
+                                    unsigned int bufferSize) {
+  if (!handle)
+    return Error::BAD_BUFFER;
+  std::lock_guard<std::mutex> buffer_lock(buffer_lock_);
+
+  uint64_t usage = descriptor.GetUsage();
+  int format = allocator_->GetImplDefinedFormat(usage, descriptor.GetFormat());
+  uint32_t layer_count = descriptor.GetLayerCount();
+
+  unsigned int size;
+  unsigned int alignedw, alignedh;
+
+  int buffer_type = GetBufferType(format);
+  BufferInfo info = GetBufferInfo(descriptor);
+  info.format = format;
+  GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh);
+  size = (bufferSize >= size) ? bufferSize : size;
+
+  int err = 0;
+  int flags = 0;
+  auto page_size = UINT(getpagesize());
+  AllocData data;
+  data.align = GetDataAlignment(format, usage);
+  data.size = size;
+  data.handle = (uintptr_t)handle;
+  data.uncached = allocator_->UseUncached(usage);
+
+  // Allocate buffer memory
+  err = allocator_->AllocateMem(&data, usage);
+  if (err) {
+    ALOGE("gralloc failed to allocate err=%s", strerror(-err));
+    return Error::NO_RESOURCES;
+  }
+
+  // Allocate memory for MetaData
+  AllocData e_data;
+  e_data.size = ALIGN(UINT(sizeof(MetaData_t)), page_size);
+  e_data.handle = data.handle;
+  e_data.align = page_size;
+
+  err = allocator_->AllocateMem(&e_data, 0);
+  if (err) {
+    ALOGE("gralloc failed to allocate metadata error=%s", strerror(-err));
+    return Error::NO_RESOURCES;
+  }
+
+  flags = GetHandleFlags(format, usage);
+  flags |= data.alloc_type;
+
+  // Create handle
+  private_handle_t *hnd = new private_handle_t(
+      data.fd, e_data.fd, flags, INT(alignedw), INT(alignedh), descriptor.GetWidth(),
+      descriptor.GetHeight(), format, buffer_type, data.size, usage);
+
+  hnd->id = ++next_id_;
+  hnd->base = 0;
+  hnd->base_metadata = 0;
+  hnd->layer_count = layer_count;
+
+  if (buffer_type == BUFFER_TYPE_VIDEO) {
+    // set default csc to 601L for only video buffers
+    ColorSpace_t colorSpace = ITU_R_601;
+    setMetaData(hnd, UPDATE_COLOR_SPACE, reinterpret_cast<void *>(&colorSpace));
+  }
+  *handle = hnd;
+  RegisterHandleLocked(hnd, data.ion_handle, e_data.ion_handle);
+  ALOGD_IF(DEBUG, "Allocated buffer handle: %p id: %" PRIu64, hnd, hnd->id);
+  if (DEBUG) {
+    private_handle_t::Dump(hnd);
+  }
+  return Error::NONE;
+}
+
+Error BufferManager::Dump(std::ostringstream *os) {
+  for (auto it : handles_map_) {
+    auto buf = it.second;
+    auto hnd = buf->handle;
+    *os << "handle id: " << std::setw(4) << hnd->id;
+    *os << " fd: " << std::setw(3) << hnd->fd;
+    *os << " fd_meta: " << std::setw(3) << hnd->fd_metadata;
+    *os << " wxh: " << std::setw(4) << hnd->width << " x " << std::setw(4) << hnd->height;
+    *os << " uwxuh: " << std::setw(4) << hnd->unaligned_width << " x ";
+    *os << std::setw(4) << hnd->unaligned_height;
+    *os << " size: " << std::setw(9) << hnd->size;
+    *os << std::hex << std::setfill('0');
+    *os << " priv_flags: "
+        << "0x" << std::setw(8) << hnd->flags;
+    *os << " usage: "
+        << "0x" << std::setw(8) << hnd->usage;
+    // TODO(user): get format string from qdutils
+    *os << " format: "
+        << "0x" << std::setw(8) << hnd->format;
+    *os << std::dec << std::setfill(' ') << std::endl;
+  }
+  return Error::NONE;
+}
+}  //  namespace gralloc
diff --git a/gralloc/gr_buf_mgr.h b/gralloc/gr_buf_mgr.h
new file mode 100644
index 0000000..414ec38
--- /dev/null
+++ b/gralloc/gr_buf_mgr.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2011-2018, The Linux Foundation. All rights reserved.
+ * Not a Contribution
+ *
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __GR_BUF_MGR_H__
+#define __GR_BUF_MGR_H__
+
+#include <pthread.h>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#include "gr_allocator.h"
+#include "gr_buf_descriptor.h"
+#include "gralloc_priv.h"
+
+namespace gralloc {
+
+using android::hardware::graphics::mapper::V2_0::Error;
+
+class BufferManager {
+ public:
+  ~BufferManager();
+
+  Error AllocateBuffer(const BufferDescriptor &descriptor, buffer_handle_t *handle,
+                       unsigned int bufferSize = 0);
+  Error RetainBuffer(private_handle_t const *hnd);
+  Error ReleaseBuffer(private_handle_t const *hnd);
+  Error LockBuffer(const private_handle_t *hnd, uint64_t usage);
+  Error UnlockBuffer(const private_handle_t *hnd);
+  Error Dump(std::ostringstream *os);
+  static BufferManager *GetInstance();
+
+ private:
+  BufferManager();
+  Error MapBuffer(private_handle_t const *hnd);
+  int GetBufferType(int format);
+  int GetHandleFlags(int format, uint64_t usage);
+
+  // Imports the ion fds into the current process. Returns an error for invalid handles
+  Error ImportHandleLocked(private_handle_t *hnd);
+
+  // Creates a Buffer from the valid private handle and adds it to the map
+  void RegisterHandleLocked(const private_handle_t *hnd, int ion_handle, int ion_handle_meta);
+
+  // Wrapper structure over private handle
+  // Values associated with the private handle
+  // that do not need to go over IPC can be placed here
+  // This structure is also not expected to be ABI stable
+  // unlike private_handle_t
+  struct Buffer {
+    const private_handle_t *handle = nullptr;
+    int ref_count = 1;
+    // Hold the main and metadata ion handles
+    // Freed from the allocator process
+    // and unused in the mapping process
+    int ion_handle_main = -1;
+    int ion_handle_meta = -1;
+
+    Buffer() = delete;
+    explicit Buffer(const private_handle_t *h, int ih_main = -1, int ih_meta = -1)
+        : handle(h), ion_handle_main(ih_main), ion_handle_meta(ih_meta) {}
+    void IncRef() { ++ref_count; }
+    bool DecRef() { return --ref_count == 0; }
+  };
+
+  Error FreeBuffer(std::shared_ptr<Buffer> buf);
+
+  // Get the wrapper Buffer object from the handle, returns nullptr if handle is not found
+  std::shared_ptr<Buffer> GetBufferFromHandleLocked(const private_handle_t *hnd);
+
+  bool map_fb_mem_ = false;
+  Allocator *allocator_ = NULL;
+  std::mutex buffer_lock_;
+  std::unordered_map<const private_handle_t *, std::shared_ptr<Buffer>> handles_map_ = {};
+  std::atomic<uint64_t> next_id_;
+};
+
+}  // namespace gralloc
+
+#endif  // __GR_BUF_MGR_H__
diff --git a/gralloc/gr_device_impl.cpp b/gralloc/gr_device_impl.cpp
new file mode 100644
index 0000000..a26ea81
--- /dev/null
+++ b/gralloc/gr_device_impl.cpp
@@ -0,0 +1,869 @@
+/*
+ * Copyright (c) 2016-2018, 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
+ * met:
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of The Linux Foundation nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
+#include <log/log.h>
+#include <cutils/trace.h>
+#include <sync/sync.h>
+#include <utils/Trace.h>
+#include <algorithm>
+#include <sstream>
+#include <string>
+
+#include "gr_buf_descriptor.h"
+#include "gr_device_impl.h"
+#include "gr_utils.h"
+#include "gralloc_priv.h"
+#include "qdMetaData.h"
+#include "qd_utils.h"
+
+int gralloc_device_open(const struct hw_module_t *module, const char *name, hw_device_t **device);
+
+int gralloc_device_close(struct hw_device_t *device);
+
+static struct hw_module_methods_t gralloc_module_methods = {.open = gralloc_device_open};
+
+struct gralloc_module_t HAL_MODULE_INFO_SYM = {
+    // clang-format off
+    .common = {
+            .tag = HARDWARE_MODULE_TAG,
+            .module_api_version = GRALLOC_MODULE_API_VERSION_1_0,
+            .hal_api_version = HARDWARE_HAL_API_VERSION,
+            .id = GRALLOC_HARDWARE_MODULE_ID,
+            .name = "Graphics Memory Module",
+            .author = "Code Aurora Forum",
+            .methods = &gralloc_module_methods,
+            .dso = 0,
+            .reserved = {0},
+        },
+    // clang-format on
+};
+
+int gralloc_device_open(const struct hw_module_t *module, const char *name, hw_device_t **device) {
+  int status = -EINVAL;
+  if (module && device && !strcmp(name, GRALLOC_HARDWARE_MODULE_ID)) {
+    gralloc::GrallocImpl * /*gralloc1_device_t*/ dev = gralloc::GrallocImpl::GetInstance(module);
+    *device = reinterpret_cast<hw_device_t *>(dev);
+    if (dev) {
+      status = 0;
+    } else {
+      ALOGE("Fatal error opening gralloc1 device");
+    }
+  }
+  return status;
+}
+
+namespace gralloc {
+
+std::atomic<uint64_t> GrallocImpl::next_descriptor_id_(1);
+
+GrallocImpl::GrallocImpl(const hw_module_t *module) {
+  common.tag = HARDWARE_DEVICE_TAG;
+  common.version = GRALLOC_MODULE_API_VERSION_1_0;
+  common.module = const_cast<hw_module_t *>(module);
+  common.close = CloseDevice;
+  getFunction = GetFunction;
+  getCapabilities = GetCapabilities;
+
+  initialized_ = Init();
+}
+
+inline gralloc1_error_t ToError(Error error) {
+  switch (error) {
+    case Error::NONE:
+      return GRALLOC1_ERROR_NONE;
+    case Error::BAD_DESCRIPTOR:
+      return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+    case Error::BAD_BUFFER:
+      return GRALLOC1_ERROR_BAD_HANDLE;
+    case Error::BAD_VALUE:
+      return GRALLOC1_ERROR_BAD_VALUE;
+    case Error::NO_RESOURCES:
+      return GRALLOC1_ERROR_NO_RESOURCES;
+    case Error::UNSUPPORTED:
+    default:
+      return GRALLOC1_ERROR_UNSUPPORTED;
+  }
+}
+
+static uint64_t ProducerUsageToBufferUsage(gralloc1_producer_usage_t producer_usage) {
+  uint64_t usage = producer_usage & ~(GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN |
+                                      GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN);
+  if ((producer_usage & GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN) ==
+      GRALLOC1_PRODUCER_USAGE_CPU_READ_OFTEN) {
+    usage |= BufferUsage::CPU_READ_OFTEN;
+  } else if ((producer_usage & GRALLOC1_PRODUCER_USAGE_CPU_READ) ==
+             GRALLOC1_PRODUCER_USAGE_CPU_READ) {
+    usage |= BufferUsage::CPU_READ_RARELY;
+  }
+
+  if ((producer_usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN) ==
+      GRALLOC1_PRODUCER_USAGE_CPU_WRITE_OFTEN) {
+    usage |= BufferUsage::CPU_WRITE_OFTEN;
+  } else if ((producer_usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE) ==
+             GRALLOC1_PRODUCER_USAGE_CPU_WRITE) {
+    usage |= BufferUsage::CPU_WRITE_RARELY;
+  }
+  return usage;
+}
+
+static uint64_t ConsumerUsageToBufferUsage(gralloc1_consumer_usage_t consumer_usage) {
+  uint64_t usage = consumer_usage & ~(GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN);
+  if ((consumer_usage & GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN) ==
+      GRALLOC1_CONSUMER_USAGE_CPU_READ_OFTEN) {
+    usage |= BufferUsage::CPU_READ_OFTEN;
+  } else if ((consumer_usage & GRALLOC1_CONSUMER_USAGE_CPU_READ) ==
+             GRALLOC1_CONSUMER_USAGE_CPU_READ) {
+    usage |= BufferUsage::CPU_READ_RARELY;
+  }
+  return usage;
+}
+
+bool GrallocImpl::Init() {
+  buf_mgr_ = BufferManager::GetInstance();
+  return buf_mgr_ != nullptr;
+}
+
+GrallocImpl::~GrallocImpl() {}
+
+gralloc1_error_t GrallocImpl::CreateBufferDescriptorLocked(
+    gralloc1_buffer_descriptor_t *descriptor_id) {
+  std::lock_guard<std::mutex> lock(descriptor_lock_);
+  auto descriptor = std::make_shared<BufferDescriptor>(next_descriptor_id_++);
+  *descriptor_id = static_cast<gralloc1_buffer_descriptor_t>(descriptor->GetId());
+  descriptors_map_.emplace(*descriptor_id, descriptor);
+  return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t GrallocImpl::DestroyBufferDescriptorLocked(
+    gralloc1_buffer_descriptor_t descriptor_id) {
+  std::lock_guard<std::mutex> lock(descriptor_lock_);
+  const auto descriptor = descriptors_map_.find(descriptor_id);
+  if (descriptor == descriptors_map_.end()) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  }
+  descriptors_map_.erase(descriptor);
+  return GRALLOC1_ERROR_NONE;
+}
+
+int GrallocImpl::CloseDevice(hw_device_t *device __unused) {
+  // No-op since the gralloc device is a singleton
+  return 0;
+}
+
+void GrallocImpl::GetCapabilities(struct gralloc1_device *device, uint32_t *out_count,
+                                  int32_t /*gralloc1_capability_t*/ *out_capabilities) {
+  if (device != nullptr && out_count != nullptr) {
+    if (out_capabilities != nullptr && *out_count >= 3) {
+      out_capabilities[0] = GRALLOC1_CAPABILITY_TEST_ALLOCATE;
+      out_capabilities[1] = GRALLOC1_CAPABILITY_LAYERED_BUFFERS;
+      out_capabilities[2] = GRALLOC1_CAPABILITY_RELEASE_IMPLY_DELETE;
+    }
+    *out_count = 3;
+  }
+  return;
+}
+
+gralloc1_function_pointer_t GrallocImpl::GetFunction(gralloc1_device_t *device, int32_t function) {
+  if (!device) {
+    return NULL;
+  }
+
+  switch (function) {
+    case GRALLOC1_FUNCTION_DUMP:
+      return reinterpret_cast<gralloc1_function_pointer_t>(Dump);
+    case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
+      return reinterpret_cast<gralloc1_function_pointer_t>(CreateBufferDescriptor);
+    case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
+      return reinterpret_cast<gralloc1_function_pointer_t>(DestroyBufferDescriptor);
+    case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(SetConsumerUsage);
+    case GRALLOC1_FUNCTION_SET_DIMENSIONS:
+      return reinterpret_cast<gralloc1_function_pointer_t>(SetBufferDimensions);
+    case GRALLOC1_FUNCTION_SET_FORMAT:
+      return reinterpret_cast<gralloc1_function_pointer_t>(SetColorFormat);
+    case GRALLOC1_FUNCTION_SET_LAYER_COUNT:
+      return reinterpret_cast<gralloc1_function_pointer_t>(SetLayerCount);
+    case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(SetProducerUsage);
+    case GRALLOC1_FUNCTION_GET_BACKING_STORE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetBackingStore);
+    case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetConsumerUsage);
+    case GRALLOC1_FUNCTION_GET_DIMENSIONS:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetBufferDimensions);
+    case GRALLOC1_FUNCTION_GET_FORMAT:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetColorFormat);
+    case GRALLOC1_FUNCTION_GET_LAYER_COUNT:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetLayerCount);
+    case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetProducerUsage);
+    case GRALLOC1_FUNCTION_GET_STRIDE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetBufferStride);
+    case GRALLOC1_FUNCTION_ALLOCATE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(AllocateBuffers);
+    case GRALLOC1_FUNCTION_RETAIN:
+      return reinterpret_cast<gralloc1_function_pointer_t>(RetainBuffer);
+    case GRALLOC1_FUNCTION_RELEASE:
+      return reinterpret_cast<gralloc1_function_pointer_t>(ReleaseBuffer);
+    case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
+      return reinterpret_cast<gralloc1_function_pointer_t>(GetNumFlexPlanes);
+    case GRALLOC1_FUNCTION_LOCK:
+      return reinterpret_cast<gralloc1_function_pointer_t>(LockBuffer);
+    case GRALLOC1_FUNCTION_LOCK_FLEX:
+      return reinterpret_cast<gralloc1_function_pointer_t>(LockFlex);
+    case GRALLOC1_FUNCTION_UNLOCK:
+      return reinterpret_cast<gralloc1_function_pointer_t>(UnlockBuffer);
+    case GRALLOC1_FUNCTION_PERFORM:
+      return reinterpret_cast<gralloc1_function_pointer_t>(Gralloc1Perform);
+    default:
+      ALOGE("%s:Gralloc Error. Client Requested for unsupported function", __FUNCTION__);
+      return NULL;
+  }
+
+  return NULL;
+}
+
+gralloc1_error_t GrallocImpl::Dump(gralloc1_device_t *device, uint32_t *out_size,
+                                   char *out_buffer) {
+  if (!device || !out_size) {
+    ALOGE("Gralloc Error : device=%p", (void *)device);
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  }
+  const size_t max_dump_size = 8192;
+  if (out_buffer == nullptr) {
+    *out_size = max_dump_size;
+  } else {
+    std::ostringstream os;
+    os << "-------------------------------" << std::endl;
+    os << "QTI gralloc dump:" << std::endl;
+    os << "-------------------------------" << std::endl;
+    GrallocImpl const *dev = GRALLOC_IMPL(device);
+    dev->buf_mgr_->Dump(&os);
+    os << "-------------------------------" << std::endl;
+    auto copied = os.str().copy(out_buffer, std::min(os.str().size(), max_dump_size), 0);
+    *out_size = UINT(copied);
+  }
+
+  return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t GrallocImpl::CheckDeviceAndHandle(gralloc1_device_t *device,
+                                                   buffer_handle_t buffer) {
+  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+  if (!device || (private_handle_t::validate(hnd) != 0)) {
+    ALOGE("Gralloc Error : device= %p, buffer-handle=%p", (void *)device, (void *)buffer);
+    return GRALLOC1_ERROR_BAD_HANDLE;
+  }
+
+  return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t GrallocImpl::CreateBufferDescriptor(gralloc1_device_t *device,
+                                                     gralloc1_buffer_descriptor_t *out_descriptor) {
+  if (!device || !out_descriptor) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  }
+  auto *dev = reinterpret_cast<GrallocImpl *>(device);
+  return dev->CreateBufferDescriptorLocked(out_descriptor);
+}
+
+gralloc1_error_t GrallocImpl::DestroyBufferDescriptor(gralloc1_device_t *device,
+                                                      gralloc1_buffer_descriptor_t descriptor) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  }
+  auto *dev = reinterpret_cast<GrallocImpl *>(device);
+  return dev->DestroyBufferDescriptorLocked(descriptor);
+}
+
+gralloc1_error_t GrallocImpl::SetConsumerUsage(gralloc1_device_t *device,
+                                               gralloc1_buffer_descriptor_t descriptor,
+                                               gralloc1_consumer_usage_t usage) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  } else {
+    auto *dev = reinterpret_cast<GrallocImpl *>(device);
+    return dev->CallBufferDescriptorFunction(descriptor, &BufferDescriptor::SetUsage,
+                                             ConsumerUsageToBufferUsage(usage));
+  }
+}
+
+gralloc1_error_t GrallocImpl::SetBufferDimensions(gralloc1_device_t *device,
+                                                  gralloc1_buffer_descriptor_t descriptor,
+                                                  uint32_t width, uint32_t height) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  } else {
+    auto *dev = reinterpret_cast<GrallocImpl *>(device);
+    return dev->CallBufferDescriptorFunction(descriptor, &BufferDescriptor::SetDimensions,
+                                             INT(width), INT(height));
+  }
+}
+
+gralloc1_error_t GrallocImpl::SetColorFormat(gralloc1_device_t *device,
+                                             gralloc1_buffer_descriptor_t descriptor,
+                                             int32_t format) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  } else {
+    auto *dev = reinterpret_cast<GrallocImpl *>(device);
+    return dev->CallBufferDescriptorFunction(descriptor, &BufferDescriptor::SetColorFormat, format);
+  }
+}
+
+gralloc1_error_t GrallocImpl::SetLayerCount(gralloc1_device_t *device,
+                                            gralloc1_buffer_descriptor_t descriptor,
+                                            uint32_t layer_count) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  } else {
+    auto *dev = reinterpret_cast<GrallocImpl *>(device);
+    return dev->CallBufferDescriptorFunction(descriptor, &BufferDescriptor::SetLayerCount,
+                                             layer_count);
+  }
+}
+
+gralloc1_error_t GrallocImpl::SetProducerUsage(gralloc1_device_t *device,
+                                               gralloc1_buffer_descriptor_t descriptor,
+                                               gralloc1_producer_usage_t usage) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  } else {
+    auto *dev = reinterpret_cast<GrallocImpl *>(device);
+    return dev->CallBufferDescriptorFunction(descriptor, &BufferDescriptor::SetUsage,
+                                             ProducerUsageToBufferUsage(usage));
+  }
+}
+
+gralloc1_error_t GrallocImpl::GetBackingStore(gralloc1_device_t *device, buffer_handle_t buffer,
+                                              gralloc1_backing_store_t *out_backstore) {
+  if (!device || !buffer) {
+    return GRALLOC1_ERROR_BAD_HANDLE;
+  }
+
+  *out_backstore =
+      static_cast<gralloc1_backing_store_t>(PRIV_HANDLE_CONST(buffer)->GetBackingstore());
+
+  return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t GrallocImpl::GetConsumerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
+                                               gralloc1_consumer_usage_t *outUsage) {
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    *outUsage = static_cast<gralloc1_consumer_usage_t>(PRIV_HANDLE_CONST(buffer)->GetUsage());
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::GetBufferDimensions(gralloc1_device_t *device, buffer_handle_t buffer,
+                                                  uint32_t *outWidth, uint32_t *outHeight) {
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+    *outWidth = UINT(hnd->GetUnalignedWidth());
+    *outHeight = UINT(hnd->GetUnalignedHeight());
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::GetColorFormat(gralloc1_device_t *device, buffer_handle_t buffer,
+                                             int32_t *outFormat) {
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    *outFormat = PRIV_HANDLE_CONST(buffer)->GetColorFormat();
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::GetLayerCount(gralloc1_device_t *device, buffer_handle_t buffer,
+                                            uint32_t *outLayerCount) {
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    *outLayerCount = PRIV_HANDLE_CONST(buffer)->GetLayerCount();
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::GetProducerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
+                                               gralloc1_producer_usage_t *outUsage) {
+  if (!outUsage) {
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    *outUsage = static_cast<gralloc1_producer_usage_t>(PRIV_HANDLE_CONST(buffer)->GetUsage());
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::GetBufferStride(gralloc1_device_t *device, buffer_handle_t buffer,
+                                              uint32_t *outStride) {
+  if (!outStride) {
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    *outStride = UINT(PRIV_HANDLE_CONST(buffer)->GetStride());
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::AllocateBuffer(const gralloc1_buffer_descriptor_t *descriptor_ids,
+                                             buffer_handle_t *out_buffers) {
+  gralloc1_error_t status = GRALLOC1_ERROR_NONE;
+
+  // Validate descriptor
+  std::lock_guard<std::mutex> descriptor_lock(descriptor_lock_);
+  std::shared_ptr<gralloc::BufferDescriptor> descriptor;
+  const auto map_descriptor = descriptors_map_.find(descriptor_ids[0]);
+  if (map_descriptor == descriptors_map_.end()) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  } else {
+    descriptor = map_descriptor->second;
+  }
+
+  // Allocate separate buffer for each descriptor
+  if (buf_mgr_->AllocateBuffer(*descriptor, &out_buffers[0]) != Error::NONE) {
+    return GRALLOC1_ERROR_NO_RESOURCES;
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::AllocateBuffers(gralloc1_device_t *device, uint32_t num_descriptors,
+                                              const gralloc1_buffer_descriptor_t *descriptors,
+                                              buffer_handle_t *out_buffers) {
+  if (!num_descriptors || !descriptors) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  }
+
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  if (num_descriptors != 1) {
+    return GRALLOC1_ERROR_UNSUPPORTED;
+  }
+
+  auto *dev = reinterpret_cast<GrallocImpl *>(device);
+  gralloc1_error_t status = dev->AllocateBuffer(descriptors, out_buffers);
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::RetainBuffer(gralloc1_device_t *device, buffer_handle_t buffer) {
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+    GrallocImpl const *dev = GRALLOC_IMPL(device);
+    status = ToError(dev->buf_mgr_->RetainBuffer(hnd));
+  }
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::ReleaseBuffer(gralloc1_device_t *device, buffer_handle_t buffer) {
+  if (!device || !buffer) {
+    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+  }
+
+  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+  GrallocImpl const *dev = GRALLOC_IMPL(device);
+  return ToError(dev->buf_mgr_->ReleaseBuffer(hnd));
+}
+
+gralloc1_error_t GrallocImpl::GetFlexLayout(const private_handle_t *hnd,
+                                            struct android_flex_layout *layout) {
+  if (!IsYuvFormat(hnd)) {
+    return GRALLOC1_ERROR_UNSUPPORTED;
+  }
+
+  android_ycbcr yuvPlaneInfo[2];
+  int err = GetYUVPlaneInfo(hnd, yuvPlaneInfo);
+
+  if (err != 0) {
+    return GRALLOC1_ERROR_BAD_HANDLE;
+  }
+
+  layout->format = FLEX_FORMAT_YCbCr;
+  layout->num_planes = 3;
+
+  for (uint32_t i = 0; i < layout->num_planes; i++) {
+    layout->planes[i].bits_per_component = 8;
+    layout->planes[i].bits_used = 8;
+    layout->planes[i].h_increment = 1;
+    layout->planes[i].v_increment = 1;
+    layout->planes[i].h_subsampling = 2;
+    layout->planes[i].v_subsampling = 2;
+  }
+
+  // We are only returning flex layout for progressive or single field formats.
+  struct android_ycbcr ycbcr = yuvPlaneInfo[0];
+  layout->planes[0].top_left = static_cast<uint8_t *>(ycbcr.y);
+  layout->planes[0].component = FLEX_COMPONENT_Y;
+  layout->planes[0].v_increment = static_cast<int32_t>(ycbcr.ystride);
+
+  layout->planes[1].top_left = static_cast<uint8_t *>(ycbcr.cb);
+  layout->planes[1].component = FLEX_COMPONENT_Cb;
+  layout->planes[1].h_increment = static_cast<int32_t>(ycbcr.chroma_step);
+  layout->planes[1].v_increment = static_cast<int32_t>(ycbcr.cstride);
+
+  layout->planes[2].top_left = static_cast<uint8_t *>(ycbcr.cr);
+  layout->planes[2].component = FLEX_COMPONENT_Cr;
+  layout->planes[2].h_increment = static_cast<int32_t>(ycbcr.chroma_step);
+  layout->planes[2].v_increment = static_cast<int32_t>(ycbcr.cstride);
+  return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t GrallocImpl::GetNumFlexPlanes(gralloc1_device_t *device, buffer_handle_t buffer,
+                                               uint32_t *out_num_planes) {
+  if (!out_num_planes) {
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status == GRALLOC1_ERROR_NONE) {
+    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+    if (!IsYuvFormat(hnd)) {
+      status = GRALLOC1_ERROR_UNSUPPORTED;
+    } else {
+      *out_num_planes = 3;
+    }
+  }
+  return status;
+}
+
+static inline void CloseFdIfValid(int fd) {
+  if (fd > 0) {
+    close(fd);
+  }
+}
+
+gralloc1_error_t GrallocImpl::LockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
+                                         gralloc1_producer_usage_t prod_usage,
+                                         gralloc1_consumer_usage_t cons_usage,
+                                         const gralloc1_rect_t *region, void **out_data,
+                                         int32_t acquire_fence) {
+  ATRACE_CALL();
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status != GRALLOC1_ERROR_NONE || !out_data ||
+      !region) {  // currently we ignore the region/rect client wants to lock
+    CloseFdIfValid(acquire_fence);
+    return status;
+  }
+
+  if (acquire_fence > 0) {
+    ATRACE_BEGIN("fence wait");
+    int error = sync_wait(acquire_fence, 1000);
+    ATRACE_END();
+    CloseFdIfValid(acquire_fence);
+    if (error < 0) {
+      ALOGE("%s: sync_wait timedout! error = %s", __FUNCTION__, strerror(errno));
+      return GRALLOC1_ERROR_UNDEFINED;
+    }
+  }
+
+  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+  GrallocImpl const *dev = GRALLOC_IMPL(device);
+
+  // Either producer usage or consumer usage must be *_USAGE_NONE
+  if ((prod_usage != GRALLOC1_PRODUCER_USAGE_NONE) &&
+      (cons_usage != GRALLOC1_CONSUMER_USAGE_NONE)) {
+    // Current gralloc1 clients do not satisfy this restriction.
+    // See b/33588773 for details
+    // return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  status = ToError(dev->buf_mgr_->LockBuffer(
+      hnd, ProducerUsageToBufferUsage(prod_usage) | ConsumerUsageToBufferUsage(cons_usage)));
+  *out_data = reinterpret_cast<void *>(hnd->base);
+
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::LockFlex(gralloc1_device_t *device, buffer_handle_t buffer,
+                                       gralloc1_producer_usage_t prod_usage,
+                                       gralloc1_consumer_usage_t cons_usage,
+                                       const gralloc1_rect_t *region,
+                                       struct android_flex_layout *out_flex_layout,
+                                       int32_t acquire_fence) {
+  if (!out_flex_layout) {
+    CloseFdIfValid(acquire_fence);
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  void *out_data{};
+  gralloc1_error_t status = GrallocImpl::LockBuffer(device, buffer, prod_usage, cons_usage, region,
+                                                    &out_data, acquire_fence);
+  if (status != GRALLOC1_ERROR_NONE) {
+    return status;
+  }
+
+  auto *dev = reinterpret_cast<GrallocImpl *>(device);
+  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+  dev->GetFlexLayout(hnd, out_flex_layout);
+  return status;
+}
+
+gralloc1_error_t GrallocImpl::UnlockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
+                                           int32_t *release_fence) {
+  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
+  if (status != GRALLOC1_ERROR_NONE) {
+    return status;
+  }
+
+  if (!release_fence) {
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
+  GrallocImpl const *dev = GRALLOC_IMPL(device);
+
+  *release_fence = -1;
+
+  return ToError(dev->buf_mgr_->UnlockBuffer(hnd));
+}
+
+static gralloc1_error_t Perform(int operation, va_list args) {
+  switch (operation) {
+    case GRALLOC_MODULE_PERFORM_GET_STRIDE: {
+      int width = va_arg(args, int);
+      int format = va_arg(args, int);
+      int *stride = va_arg(args, int *);
+      unsigned int alignedw = 0, alignedh = 0;
+
+      if (!stride) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      BufferInfo info(width, width, format);
+      GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
+      *stride = INT(alignedw);
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      int *stride = va_arg(args, int *);
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!stride) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      BufferDim_t buffer_dim;
+      if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
+        *stride = buffer_dim.sliceWidth;
+      } else {
+        *stride = hnd->width;
+      }
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      int *stride = va_arg(args, int *);
+      int *height = va_arg(args, int *);
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!stride || !height) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      GetCustomDimensions(hnd, stride, height);
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES: {
+      int width = va_arg(args, int);
+      int height = va_arg(args, int);
+      int format = va_arg(args, int);
+      uint64_t usage = va_arg(args, uint64_t);
+      usage |= va_arg(args, uint64_t);
+
+      int *aligned_width = va_arg(args, int *);
+      int *aligned_height = va_arg(args, int *);
+      int *tile_enabled = va_arg(args, int *);
+      if (!aligned_width || !aligned_height || !tile_enabled) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      unsigned int alignedw, alignedh;
+      BufferInfo info(width, height, format, usage);
+      *tile_enabled = IsUBwcEnabled(format, usage);
+      GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
+      *aligned_width = INT(alignedw);
+      *aligned_height = INT(alignedh);
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      int *color_space = va_arg(args, int *);
+
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!color_space) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      *color_space = 0;
+      GetColorSpaceFromMetadata(hnd, color_space);
+    } break;
+    case GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      android_ycbcr *ycbcr = va_arg(args, struct android_ycbcr *);
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!ycbcr) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      if (GetYUVPlaneInfo(hnd, ycbcr)) {
+        return GRALLOC1_ERROR_UNDEFINED;
+      }
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      int *map_secure_buffer = va_arg(args, int *);
+
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!map_secure_buffer) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      if (getMetaData(hnd, GET_MAP_SECURE_BUFFER, map_secure_buffer) != 0) {
+        *map_secure_buffer = 0;
+      }
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      int *flag = va_arg(args, int *);
+
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!flag) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      *flag = hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
+      int linear_format = 0;
+      if (getMetaData(hnd, GET_LINEAR_FORMAT, &linear_format) == 0) {
+        if (linear_format) {
+          *flag = 0;
+        }
+      }
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      void **rgb_data = va_arg(args, void **);
+
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!rgb_data) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      if (GetRgbDataAddress(hnd, rgb_data)) {
+        return GRALLOC1_ERROR_UNDEFINED;
+      }
+    } break;
+
+    case GRALLOC1_MODULE_PERFORM_GET_INTERLACE_FLAG: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      int *flag = va_arg(args, int *);
+
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+
+      if (!flag) {
+        return GRALLOC1_ERROR_BAD_VALUE;
+      }
+
+      if (getMetaData(hnd, GET_PP_PARAM_INTERLACED, flag) != 0) {
+        *flag = 0;
+      }
+    } break;
+
+    case GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE: {
+      private_handle_t *hnd = va_arg(args, private_handle_t *);
+      uint32_t *enable = va_arg(args, uint32_t *);
+      if (private_handle_t::validate(hnd) != 0) {
+        return GRALLOC1_ERROR_BAD_HANDLE;
+      }
+      if (setMetaData(hnd, SET_SINGLE_BUFFER_MODE, enable) != 0) {
+        return GRALLOC1_ERROR_UNSUPPORTED;
+      }
+    } break;
+
+    default:
+      break;
+  }
+  return GRALLOC1_ERROR_NONE;
+}
+
+gralloc1_error_t GrallocImpl::Gralloc1Perform(gralloc1_device_t *device, int operation, ...) {
+  if (!device) {
+    return GRALLOC1_ERROR_BAD_VALUE;
+  }
+
+  va_list args;
+  va_start(args, operation);
+  gralloc1_error_t err = Perform(operation, args);
+  va_end(args);
+
+  return err;
+}
+
+}  // namespace gralloc
diff --git a/libgralloc1/gr_device_impl.h b/gralloc/gr_device_impl.h
similarity index 81%
rename from libgralloc1/gr_device_impl.h
rename to gralloc/gr_device_impl.h
index 55ce44b..82e9e71 100644
--- a/libgralloc1/gr_device_impl.h
+++ b/gralloc/gr_device_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016-2017, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2018, 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
@@ -30,8 +30,8 @@
 #ifndef __GR_DEVICE_IMPL_H__
 #define __GR_DEVICE_IMPL_H__
 
-#include <hardware/hardware.h>
 #include <hardware/gralloc1.h>
+#include <hardware/hardware.h>
 #include "gr_buf_mgr.h"
 
 struct private_module_t {
@@ -40,7 +40,7 @@
 
 #define GRALLOC_IMPL(exp) reinterpret_cast<GrallocImpl const *>(exp)
 
-namespace gralloc1 {
+namespace gralloc {
 
 class GrallocImpl : public gralloc1_device_t {
  public:
@@ -50,7 +50,7 @@
   static gralloc1_function_pointer_t GetFunction(
       struct gralloc1_device *device, int32_t /*gralloc1_function_descriptor_t*/ descriptor);
 
-  static GrallocImpl* GetInstance(const struct hw_module_t *module) {
+  static GrallocImpl *GetInstance(const struct hw_module_t *module) {
     static GrallocImpl *instance = new GrallocImpl(module);
     if (instance->IsInitialized()) {
       return instance;
@@ -119,15 +119,39 @@
                                        int32_t *release_fence);
   static gralloc1_error_t Gralloc1Perform(gralloc1_device_t *device, int operation, ...);
 
+  gralloc1_error_t CreateBufferDescriptorLocked(gralloc1_buffer_descriptor_t *descriptor_id);
+  gralloc1_error_t DestroyBufferDescriptorLocked(gralloc1_buffer_descriptor_t descriptor_id);
+  gralloc1_error_t AllocateBuffer(const gralloc1_buffer_descriptor_t *descriptor_ids,
+                                  buffer_handle_t *out_buffers);
+  gralloc1_error_t GetFlexLayout(const private_handle_t *hnd, struct android_flex_layout *layout);
+
+  template <typename... Args>
+  gralloc1_error_t CallBufferDescriptorFunction(gralloc1_buffer_descriptor_t descriptor_id,
+                                                void (BufferDescriptor::*member)(Args...),
+                                                Args... args) {
+    std::lock_guard<std::mutex> lock(descriptor_lock_);
+    const auto map_descriptor = descriptors_map_.find(descriptor_id);
+    if (map_descriptor == descriptors_map_.end()) {
+      return GRALLOC1_ERROR_BAD_DESCRIPTOR;
+    }
+    const auto descriptor = map_descriptor->second;
+    (descriptor.get()->*member)(std::forward<Args>(args)...);
+    return GRALLOC1_ERROR_NONE;
+  }
+
   explicit GrallocImpl(const hw_module_t *module);
   ~GrallocImpl();
   bool Init();
-  bool IsInitialized() const { return initalized_; }
+  bool IsInitialized() const { return initialized_; }
 
   BufferManager *buf_mgr_ = NULL;
-  bool initalized_ = false;
+  bool initialized_ = false;
+  std::mutex descriptor_lock_;
+  std::unordered_map<gralloc1_buffer_descriptor_t, std::shared_ptr<gralloc::BufferDescriptor>>
+      descriptors_map_ = {};
+  static std::atomic<uint64_t> next_descriptor_id_;
 };
 
-}  // namespace gralloc1
+}  // namespace gralloc
 
 #endif  // __GR_DEVICE_IMPL_H__
diff --git a/libgralloc1/gr_ion_alloc.cpp b/gralloc/gr_ion_alloc.cpp
similarity index 98%
rename from libgralloc1/gr_ion_alloc.cpp
rename to gralloc/gr_ion_alloc.cpp
index 4fc67f4..36de059 100644
--- a/libgralloc1/gr_ion_alloc.cpp
+++ b/gralloc/gr_ion_alloc.cpp
@@ -33,22 +33,22 @@
 #include <sys/mman.h>
 #include <linux/msm_ion.h>
 #if TARGET_ION_ABI_VERSION >= 2
-#include <ion/ion.h>
 #include <linux/dma-buf.h>
+#include <ion/ion.h>
 #endif
 #include <stdlib.h>
 #include <fcntl.h>
-#include <cutils/log.h>
+#include <log/log.h>
+#include <cutils/trace.h>
 #include <errno.h>
 #include <utils/Trace.h>
-#include <cutils/trace.h>
 #include <string>
 
-#include "gralloc_priv.h"
 #include "gr_utils.h"
+#include "gralloc_priv.h"
 #include "gr_ion_alloc.h"
 
-namespace gralloc1 {
+namespace gralloc {
 
 bool IonAlloc::Init() {
   if (ion_dev_fd_ == FD_INIT) {
@@ -207,8 +207,8 @@
 
   data->fd = fd_data.fd;
   data->ion_handle = handle_data.handle;
-  ALOGD_IF(DEBUG, "ion: Allocated buffer size:%zu fd:%d handle:0x%x",
-          ion_alloc_data.len, data->fd, data->ion_handle);
+  ALOGD_IF(DEBUG, "ion: Allocated buffer size:%zu fd:%d handle:0x%x", ion_alloc_data.len, data->fd,
+           data->ion_handle);
 
   return 0;
 }
@@ -342,4 +342,4 @@
   return err;
 }
 
-}  // namespace gralloc1
+}  // namespace gralloc
diff --git a/libgralloc1/gr_ion_alloc.h b/gralloc/gr_ion_alloc.h
similarity index 97%
rename from libgralloc1/gr_ion_alloc.h
rename to gralloc/gr_ion_alloc.h
index b41f5f1..763ac54 100644
--- a/libgralloc1/gr_ion_alloc.h
+++ b/gralloc/gr_ion_alloc.h
@@ -34,7 +34,7 @@
 
 #define FD_INIT -1
 
-namespace gralloc1 {
+namespace gralloc {
 
 enum {
   CACHE_CLEAN = 0x1,
@@ -81,6 +81,6 @@
   int ion_dev_fd_;
 };
 
-}  // namespace gralloc1
+}  // namespace gralloc
 
 #endif  // __GR_ION_ALLOC_H__
diff --git a/libgralloc1/gr_priv_handle.h b/gralloc/gr_priv_handle.h
similarity index 68%
rename from libgralloc1/gr_priv_handle.h
rename to gralloc/gr_priv_handle.h
index 49e09a5..1eb03b8 100644
--- a/libgralloc1/gr_priv_handle.h
+++ b/gralloc/gr_priv_handle.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2018, The Linux Foundation. All rights reserved.
  * Not a Contribution
  *
  * Copyright (C) 2008 The Android Open Source Project
@@ -20,9 +20,9 @@
 #ifndef __GR_PRIV_HANDLE_H__
 #define __GR_PRIV_HANDLE_H__
 
-#include <cutils/log.h>
-#include <hardware/gralloc1.h>
+#include <log/log.h>
 #include <hardware/gralloc.h>
+#include <hardware/gralloc1.h>
 #include <cinttypes>
 
 #define GRALLOC1_FUNCTION_PERFORM 0x00001000
@@ -57,7 +57,7 @@
     PRIV_FLAGS_CPU_RENDERED = 0x04000000,
     PRIV_FLAGS_UBWC_ALIGNED = 0x08000000,
     PRIV_FLAGS_DISP_CONSUMER = 0x10000000,
-    PRIV_FLAGS_CLIENT_ALLOCATED = 0x20000000,   // Ion buffer allocated outside of gralloc
+    PRIV_FLAGS_CLIENT_ALLOCATED = 0x20000000,  // Ion buffer allocated outside of gralloc
   };
 
   // file-descriptors dup'd over IPC
@@ -67,43 +67,32 @@
   // values sent over IPC
   int magic;
   int flags;
-  int width;        // holds width of the actual buffer allocated
-  int height;       // holds height of the  actual buffer allocated
+  int width;             // holds width of the actual buffer allocated
+  int height;            // holds height of the  actual buffer allocated
   int unaligned_width;   // holds width client asked to allocate
   int unaligned_height;  // holds height client asked to allocate
   int format;
   int buffer_type;
+  unsigned int layer_count;
+  uint64_t id __attribute__((aligned(8)));
+  uint64_t usage __attribute__((aligned(8)));
+
   unsigned int size;
   unsigned int offset;
   unsigned int offset_metadata;
-  uint64_t base                            __attribute__((aligned(8)));
-  uint64_t base_metadata                   __attribute__((aligned(8)));
-  uint64_t gpuaddr                         __attribute__((aligned(8)));
-  uint64_t id                              __attribute__((aligned(8)));
-  gralloc1_producer_usage_t producer_usage __attribute__((aligned(8)));
-  gralloc1_consumer_usage_t consumer_usage __attribute__((aligned(8)));
-  unsigned int layer_count;
+  uint64_t base __attribute__((aligned(8)));
+  uint64_t base_metadata __attribute__((aligned(8)));
+  uint64_t gpuaddr __attribute__((aligned(8)));
 
   static const int kNumFds = 2;
   static const int kMagic = 'gmsm';
 
   static inline int NumInts() {
-    return ((sizeof(private_handle_t) - sizeof(native_handle_t)) / sizeof(int))
-        - kNumFds;
+    return ((sizeof(private_handle_t) - sizeof(native_handle_t)) / sizeof(int)) - kNumFds;
   }
 
-  private_handle_t(int fd,
-                   int meta_fd,
-                   int flags,
-                   int width,
-                   int height,
-                   int uw,
-                   int uh,
-                   int format,
-                   int buf_type,
-                   unsigned int size,
-                   gralloc1_producer_usage_t prod_usage = GRALLOC1_PRODUCER_USAGE_NONE,
-                   gralloc1_consumer_usage_t cons_usage = GRALLOC1_CONSUMER_USAGE_NONE)
+  private_handle_t(int fd, int meta_fd, int flags, int width, int height, int uw, int uh,
+                   int format, int buf_type, unsigned int size, uint64_t usage = 0)
       : fd(fd),
         fd_metadata(meta_fd),
         magic(kMagic),
@@ -114,27 +103,24 @@
         unaligned_height(uh),
         format(format),
         buffer_type(buf_type),
+        layer_count(1),
+        id(0),
+        usage(usage),
         size(size),
         offset(0),
         offset_metadata(0),
         base(0),
         base_metadata(0),
-        gpuaddr(0),
-        id(0),
-        producer_usage(prod_usage),
-        consumer_usage(cons_usage),
-        layer_count(1) {
+        gpuaddr(0) {
     version = static_cast<int>(sizeof(native_handle));
     numInts = NumInts();
     numFds = kNumFds;
   }
 
-// Legacy constructor used by some clients
+  // Legacy constructor used by some clients
   private_handle_t(int fd, unsigned int size, int usage, int buf_type, int format, int w, int h)
-  : private_handle_t(fd, -1, PRIV_FLAGS_CLIENT_ALLOCATED, w, h, 0, 0, format, buf_type, size,
-                     static_cast<gralloc1_producer_usage_t>(usage),
-                     static_cast<gralloc1_consumer_usage_t>(usage)) {
-  }
+      : private_handle_t(fd, -1, PRIV_FLAGS_CLIENT_ALLOCATED, w, h, 0, 0, format, buf_type, size,
+                         static_cast<uint64_t>(usage)) {}
 
   ~private_handle_t() {
     magic = 0;
@@ -142,7 +128,7 @@
   }
 
   static int validate(const native_handle *h) {
-    const private_handle_t *hnd = (const private_handle_t *)h;
+    auto *hnd = static_cast<const private_handle_t *>(h);
     if (!h || h->version != sizeof(native_handle) || h->numInts != NumInts() ||
         h->numFds != kNumFds || hnd->magic != kMagic) {
       ALOGE(
@@ -162,11 +148,11 @@
   }
 
   static void Dump(const private_handle_t *hnd) {
-    ALOGD("handle id:%" PRIu64 " wxh:%dx%d uwxuh:%dx%d size: %d fd:%d fd_meta:%d flags:0x%x "
-          "prod_usage:0x%" PRIx64" cons_usage:0x%" PRIx64 " format:0x%x layer_count: %d",
+    ALOGD("handle id:%" PRIu64
+          " wxh:%dx%d uwxuh:%dx%d size: %d fd:%d fd_meta:%d flags:0x%x "
+          "usage:0x%" PRIx64 "  format:0x%x layer_count: %d",
           hnd->id, hnd->width, hnd->height, hnd->unaligned_width, hnd->unaligned_height, hnd->size,
-          hnd->fd, hnd->fd_metadata, hnd->flags, hnd->producer_usage, hnd->consumer_usage,
-          hnd->format, hnd->layer_count);
+          hnd->fd, hnd->fd_metadata, hnd->flags, hnd->usage, hnd->format, hnd->layer_count);
   }
 
   int GetUnalignedWidth() const { return unaligned_width; }
@@ -182,9 +168,7 @@
     return width;
   }
 
-  gralloc1_consumer_usage_t GetConsumerUsage() const { return consumer_usage; }
-
-  gralloc1_producer_usage_t GetProducerUsage() const { return producer_usage; }
+  uint64_t GetUsage() const { return usage; }
 
   uint64_t GetBackingstore() const { return id; }
 };
diff --git a/libgralloc1/gr_utils.cpp b/gralloc/gr_utils.cpp
similarity index 77%
rename from libgralloc1/gr_utils.cpp
rename to gralloc/gr_utils.cpp
index 2eb0b11..f7ddac6 100644
--- a/libgralloc1/gr_utils.cpp
+++ b/gralloc/gr_utils.cpp
@@ -30,8 +30,8 @@
 #include <media/msm_media_info.h>
 #include <algorithm>
 
-#include "gr_utils.h"
 #include "gr_adreno_info.h"
+#include "gr_utils.h"
 #include "qdMetaData.h"
 
 #define ASTC_BLOCK_SIZE 16
@@ -40,14 +40,14 @@
 #define COLOR_FMT_P010_UBWC 9
 #endif
 
-namespace gralloc1 {
+namespace gralloc {
 
 bool IsYuvFormat(const private_handle_t *hnd) {
   switch (hnd->format) {
     case HAL_PIXEL_FORMAT_YCbCr_420_SP:
     case HAL_PIXEL_FORMAT_YCbCr_422_SP:
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:   // Same as YCbCr_420_SP_VENUS
+    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:  // Same as YCbCr_420_SP_VENUS
     case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC:
     case HAL_PIXEL_FORMAT_YCrCb_420_SP:
     case HAL_PIXEL_FORMAT_YCrCb_422_SP:
@@ -177,24 +177,20 @@
   return bpp;
 }
 
-bool CpuCanAccess(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage) {
-  return CpuCanRead(prod_usage, cons_usage) || CpuCanWrite(prod_usage);
+bool CpuCanAccess(uint64_t usage) {
+  return CpuCanRead(usage) || CpuCanWrite(usage);
 }
 
-bool CpuCanRead(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage) {
-  if (prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_READ) {
-    return true;
-  }
-
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_CPU_READ) {
+bool CpuCanRead(uint64_t usage) {
+  if (usage & BufferUsage::CPU_READ_MASK) {
     return true;
   }
 
   return false;
 }
 
-bool CpuCanWrite(gralloc1_producer_usage_t prod_usage) {
-  if (prod_usage & GRALLOC1_PRODUCER_USAGE_CPU_WRITE) {
+bool CpuCanWrite(uint64_t usage) {
+  if (usage & BufferUsage::CPU_WRITE_MASK) {
     // Application intends to use CPU for rendering
     return true;
   }
@@ -202,121 +198,131 @@
   return false;
 }
 
-unsigned int GetSize(const BufferInfo &info, unsigned int alignedw,
-                     unsigned int alignedh) {
+uint32_t GetDataAlignment(int format, uint64_t usage) {
+  uint32_t align = UINT(getpagesize());
+  if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) {
+    align = SIZE_8K;
+  }
+
+  if (usage & BufferUsage::PROTECTED) {
+    if ((usage & BufferUsage::CAMERA_OUTPUT) || (usage & GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY)) {
+      // The alignment here reflects qsee mmu V7L/V8L requirement
+      align = SZ_2M;
+    } else {
+      align = SECURE_ALIGN;
+    }
+  }
+
+  return align;
+}
+
+// Returns the final buffer size meant to be allocated with ion
+unsigned int GetSize(const BufferInfo &info, unsigned int alignedw, unsigned int alignedh) {
   unsigned int size = 0;
   int format = info.format;
   int width = info.width;
   int height = info.height;
-  gralloc1_producer_usage_t prod_usage = info.prod_usage;
-  gralloc1_consumer_usage_t cons_usage = info.cons_usage;
+  uint64_t usage = info.usage;
 
-  if (IsUBwcEnabled(format, prod_usage, cons_usage)) {
-    return GetUBwcSize(width, height, format, alignedw, alignedh);
-  }
-
-  if (IsUncompressedRGBFormat(format)) {
+  if (IsUBwcEnabled(format, usage)) {
+    size = GetUBwcSize(width, height, format, alignedw, alignedh);
+  } else if (IsUncompressedRGBFormat(format)) {
     uint32_t bpp = GetBppForUncompressedRGB(format);
     size = alignedw * alignedh * bpp;
-    return size;
-  }
-
-  if (IsCompressedRGBFormat(format)) {
+  } else if (IsCompressedRGBFormat(format)) {
     size = alignedw * alignedh * ASTC_BLOCK_SIZE;
-    return size;
+  } else {
+    // Below switch should be for only YUV/custom formats
+    switch (format) {
+      case HAL_PIXEL_FORMAT_RAW16:
+      case HAL_PIXEL_FORMAT_Y16:size = alignedw * alignedh * 2;
+        break;
+      case HAL_PIXEL_FORMAT_RAW10:
+      case HAL_PIXEL_FORMAT_RAW12:size = ALIGN(alignedw * alignedh, SIZE_4K);
+        break;
+      case HAL_PIXEL_FORMAT_RAW8:
+      case HAL_PIXEL_FORMAT_Y8:size = alignedw * alignedh * 1;
+        break;
+        // adreno formats
+      case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:  // NV21
+        size = ALIGN(alignedw * alignedh, SIZE_4K);
+        size += (unsigned int) ALIGN(2 * ALIGN(width / 2, 32) * ALIGN(height / 2, 32), SIZE_4K);
+        break;
+      case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:  // NV12
+        // The chroma plane is subsampled,
+        // but the pitch in bytes is unchanged
+        // The GPU needs 4K alignment, but the video decoder needs 8K
+        size = ALIGN(alignedw * alignedh, SIZE_8K);
+        size += ALIGN(alignedw * (unsigned int) ALIGN(height / 2, 32), SIZE_8K);
+        break;
+      case HAL_PIXEL_FORMAT_YV12:
+        if ((format == HAL_PIXEL_FORMAT_YV12) && ((width & 1) || (height & 1))) {
+          ALOGE("w or h is odd for the YV12 format");
+          return 0;
+        }
+        size = alignedw * alignedh + (ALIGN(alignedw / 2, 16) * (alignedh / 2)) * 2;
+        size = ALIGN(size, (unsigned int) SIZE_4K);
+        break;
+      case HAL_PIXEL_FORMAT_YCbCr_420_SP:
+      case HAL_PIXEL_FORMAT_YCrCb_420_SP:
+        size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2 + 1, SIZE_4K);
+        break;
+      case HAL_PIXEL_FORMAT_YCbCr_420_P010:
+        size = ALIGN((alignedw * alignedh * 2) + (alignedw * alignedh) + 1, SIZE_4K);
+        break;
+      case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
+        size = VENUS_BUFFER_SIZE(COLOR_FMT_P010,
+                                 width,
+                                 height);
+        break;
+      case HAL_PIXEL_FORMAT_YCbCr_422_SP:
+      case HAL_PIXEL_FORMAT_YCrCb_422_SP:
+      case HAL_PIXEL_FORMAT_YCbCr_422_I:
+      case HAL_PIXEL_FORMAT_YCrCb_422_I:
+      case HAL_PIXEL_FORMAT_CbYCrY_422_I:
+        if (width & 1) {
+          ALOGE("width is odd for the YUV422_SP format");
+          return 0;
+        }
+        size = ALIGN(alignedw * alignedh * 2, SIZE_4K);
+        break;
+      case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
+      case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
+        size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
+        break;
+      case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
+      case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
+        size = VENUS_BUFFER_SIZE(COLOR_FMT_NV21, width, height);
+        break;
+      case HAL_PIXEL_FORMAT_BLOB:
+      case HAL_PIXEL_FORMAT_RAW_OPAQUE:
+        if (height != 1) {
+          ALOGE("%s: Buffers with HAL_PIXEL_FORMAT_BLOB must have height 1 ", __FUNCTION__);
+          return 0;
+        }
+        size = (unsigned int) width;
+        break;
+      case HAL_PIXEL_FORMAT_NV21_ZSL:
+        size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2,
+                     SIZE_4K);
+        break;
+      default:ALOGE("%s: Unrecognized pixel format: 0x%x", __FUNCTION__, format);
+        return 0;
+    }
   }
-
-  // Below switch should be for only YUV/custom formats
-  switch (format) {
-    case HAL_PIXEL_FORMAT_RAW16:
-    case HAL_PIXEL_FORMAT_Y16:
-      size = alignedw * alignedh * 2;
-      break;
-    case HAL_PIXEL_FORMAT_RAW10:
-    case HAL_PIXEL_FORMAT_RAW12:
-      size = ALIGN(alignedw * alignedh, SIZE_4K);
-      break;
-    case HAL_PIXEL_FORMAT_RAW8:
-    case HAL_PIXEL_FORMAT_Y8:
-      size = alignedw * alignedh * 1;
-      break;
-
-      // adreno formats
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO:  // NV21
-      size = ALIGN(alignedw * alignedh, SIZE_4K);
-      size += (unsigned int)ALIGN(2 * ALIGN(width / 2, 32) * ALIGN(height / 2, 32), SIZE_4K);
-      break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED:  // NV12
-      // The chroma plane is subsampled,
-      // but the pitch in bytes is unchanged
-      // The GPU needs 4K alignment, but the video decoder needs 8K
-      size = ALIGN(alignedw * alignedh, SIZE_8K);
-      size += ALIGN(alignedw * (unsigned int)ALIGN(height / 2, 32), SIZE_8K);
-      break;
-    case HAL_PIXEL_FORMAT_YV12:
-      if ((format == HAL_PIXEL_FORMAT_YV12) && ((width & 1) || (height & 1))) {
-        ALOGE("w or h is odd for the YV12 format");
-        return 0;
-      }
-      size = alignedw * alignedh + (ALIGN(alignedw / 2, 16) * (alignedh / 2)) * 2;
-      size = ALIGN(size, (unsigned int)SIZE_4K);
-      break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP:
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP:
-      size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2 + 1, SIZE_4K);
-      break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_P010:
-      size = ALIGN((alignedw * alignedh * 2) + (alignedw * alignedh) + 1, SIZE_4K);
-      break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS:
-      size = VENUS_BUFFER_SIZE(COLOR_FMT_P010, width, height);
-      break;
-    case HAL_PIXEL_FORMAT_YCbCr_422_SP:
-    case HAL_PIXEL_FORMAT_YCrCb_422_SP:
-    case HAL_PIXEL_FORMAT_YCbCr_422_I:
-    case HAL_PIXEL_FORMAT_YCrCb_422_I:
-    case HAL_PIXEL_FORMAT_CbYCrY_422_I:
-      if (width & 1) {
-        ALOGE("width is odd for the YUV422_SP format");
-        return 0;
-      }
-      size = ALIGN(alignedw * alignedh * 2, SIZE_4K);
-      break;
-    case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS:
-    case HAL_PIXEL_FORMAT_NV12_ENCODEABLE:
-      size = VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
-      break;
-    case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS:
-    case HAL_PIXEL_FORMAT_NV21_ENCODEABLE:
-      size = VENUS_BUFFER_SIZE(COLOR_FMT_NV21, width, height);
-      break;
-    case HAL_PIXEL_FORMAT_BLOB:
-    case HAL_PIXEL_FORMAT_RAW_OPAQUE:
-      if (height != 1) {
-        ALOGE("%s: Buffers with HAL_PIXEL_FORMAT_BLOB must have height 1 ", __FUNCTION__);
-        return 0;
-      }
-      size = (unsigned int)width;
-      break;
-    case HAL_PIXEL_FORMAT_NV21_ZSL:
-      size = ALIGN((alignedw * alignedh) + (alignedw * alignedh) / 2, SIZE_4K);
-      break;
-    default:
-      ALOGE("%s: Unrecognized pixel format: 0x%x", __FUNCTION__, format);
-      return 0;
-  }
-
+  auto align = GetDataAlignment(format, usage);
+  size = ALIGN(size, align) * info.layer_count;
   return size;
 }
 
-void GetBufferSizeAndDimensions(const BufferInfo &info, unsigned int *size,
-                                unsigned int *alignedw, unsigned int *alignedh) {
+void GetBufferSizeAndDimensions(const BufferInfo &info, unsigned int *size, unsigned int *alignedw,
+                                unsigned int *alignedh) {
   GetAlignedWidthAndHeight(info, alignedw, alignedh);
   *size = GetSize(info, *alignedw, *alignedh);
 }
 
-void GetYuvUbwcSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height,
-                           int color_format, struct android_ycbcr *ycbcr) {
+void GetYuvUbwcSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, int color_format,
+                           struct android_ycbcr *ycbcr) {
   // UBWC buffer has these 4 planes in the following sequence:
   // Y_Meta_Plane, Y_Plane, UV_Meta_Plane, UV_Plane
   unsigned int y_meta_stride, y_meta_height, y_meta_size;
@@ -384,8 +390,7 @@
   uint32_t width = UINT(hnd->width);
   uint32_t height = UINT(hnd->height);
   int format = hnd->format;
-  gralloc1_producer_usage_t prod_usage = hnd->GetProducerUsage();
-  gralloc1_consumer_usage_t cons_usage = hnd->GetConsumerUsage();
+  uint64_t usage = hnd->usage;
   unsigned int ystride, cstride;
   bool interlaced = false;
 
@@ -393,29 +398,21 @@
 
   // Check if UBWC buffer has been rendered in linear format.
   int linear_format = 0;
-  if (getMetaData(const_cast<private_handle_t *>(hnd),
-                  GET_LINEAR_FORMAT, &linear_format) == 0) {
-      format = INT(linear_format);
+  if (getMetaData(const_cast<private_handle_t *>(hnd), GET_LINEAR_FORMAT, &linear_format) == 0) {
+    format = INT(linear_format);
   }
 
   // Check metadata if the geometry has been updated.
   BufferDim_t buffer_dim;
-  if (getMetaData(const_cast<private_handle_t *>(hnd),
-                  GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
-    int usage = 0;
-    if (hnd->flags & private_handle_t::PRIV_FLAGS_UBWC_ALIGNED) {
-      usage = GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC;
-    }
-
-    BufferInfo info(buffer_dim.sliceWidth, buffer_dim.sliceHeight, format,
-                    prod_usage, cons_usage);
+  if (getMetaData(const_cast<private_handle_t *>(hnd), GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
+    BufferInfo info(buffer_dim.sliceWidth, buffer_dim.sliceHeight, format, usage);
     GetAlignedWidthAndHeight(info, &width, &height);
   }
 
   // Check metadata for interlaced content.
   int interlace_flag = 0;
-  if (getMetaData(const_cast<private_handle_t *>(hnd),
-                  GET_PP_PARAM_INTERLACED, &interlace_flag) == 0) {
+  if (getMetaData(const_cast<private_handle_t *>(hnd), GET_PP_PARAM_INTERLACED, &interlace_flag) ==
+      0) {
     interlaced = interlace_flag;
   }
 
@@ -458,8 +455,8 @@
       ystride = VENUS_Y_STRIDE(COLOR_FMT_P010, width);
       cstride = VENUS_UV_STRIDE(COLOR_FMT_P010, width);
       ycbcr->y = reinterpret_cast<void *>(hnd->base);
-      ycbcr->cb = reinterpret_cast<void *>(hnd->base +
-                                           ystride * VENUS_Y_SCANLINES(COLOR_FMT_P010, height));
+      ycbcr->cb =
+          reinterpret_cast<void *>(hnd->base + ystride * VENUS_Y_SCANLINES(COLOR_FMT_P010, height));
       ycbcr->cr = reinterpret_cast<void *>(hnd->base +
                                            ystride * VENUS_Y_SCANLINES(COLOR_FMT_P010, height) + 1);
       ycbcr->ystride = ystride;
@@ -495,7 +492,7 @@
     case HAL_PIXEL_FORMAT_CbYCrY_422_I:
       ystride = width * 2;
       cstride = 0;
-      ycbcr->y  = reinterpret_cast<void *>(hnd->base);
+      ycbcr->y = reinterpret_cast<void *>(hnd->base);
       ycbcr->cr = NULL;
       ycbcr->cb = NULL;
       ycbcr->ystride = ystride;
@@ -544,8 +541,7 @@
   return false;
 }
 
-bool IsUBwcEnabled(int format, gralloc1_producer_usage_t prod_usage,
-                   gralloc1_consumer_usage_t cons_usage) {
+bool IsUBwcEnabled(int format, uint64_t usage) {
   // Allow UBWC, if client is using an explicitly defined UBWC pixel format.
   if (IsUBwcFormat(format)) {
     return true;
@@ -554,18 +550,17 @@
   // Allow UBWC, if an OpenGL client sets UBWC usage flag and GPU plus MDP
   // support the format. OR if a non-OpenGL client like Rotator, sets UBWC
   // usage flag and MDP supports the format.
-  if ((prod_usage & GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC) && IsUBwcSupported(format)) {
+  if ((usage & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) && IsUBwcSupported(format)) {
     bool enable = true;
     // Query GPU for UBWC only if buffer is intended to be used by GPU.
-    if ((cons_usage & GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE) ||
-        (prod_usage & GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET)) {
+    if ((usage & BufferUsage::GPU_TEXTURE) || (usage & BufferUsage::GPU_RENDER_TARGET)) {
       if (AdrenoMemInfo::GetInstance()) {
         enable = AdrenoMemInfo::GetInstance()->IsUBWCSupportedByGPU(format);
       }
     }
 
     // Allow UBWC, only if CPU usage flags are not set
-    if (enable && !(CpuCanAccess(prod_usage, cons_usage))) {
+    if (enable && !(CpuCanAccess(usage))) {
       return true;
     }
   }
@@ -684,7 +679,7 @@
   int err = 0;
 
   // This api is for RGB* formats
-  if (!gralloc1::IsUncompressedRGBFormat(hnd->format)) {
+  if (!IsUncompressedRGBFormat(hnd->format)) {
     return -EINVAL;
   }
 
@@ -714,16 +709,60 @@
   return err;
 }
 
+void GetCustomDimensions(private_handle_t *hnd, int *stride, int *height) {
+  BufferDim_t buffer_dim;
+  int interlaced = 0;
+
+  *stride = hnd->width;
+  *height = hnd->height;
+  if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
+    *stride = buffer_dim.sliceWidth;
+    *height = buffer_dim.sliceHeight;
+  } else if (getMetaData(hnd, GET_PP_PARAM_INTERLACED, &interlaced) == 0) {
+    if (interlaced && IsUBwcFormat(hnd->format)) {
+      unsigned int alignedw = 0, alignedh = 0;
+      // Get re-aligned height for single ubwc interlaced field and
+      // multiply by 2 to get frame height.
+      BufferInfo info(hnd->width, ((hnd->height + 1) >> 1), hnd->format);
+      GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
+      *stride = static_cast<int>(alignedw);
+      *height = static_cast<int>(alignedh * 2);
+    }
+  }
+}
+
+void GetColorSpaceFromMetadata(private_handle_t *hnd, int *color_space) {
+  ColorMetaData color_metadata;
+  if (getMetaData(hnd, GET_COLOR_METADATA, &color_metadata) == 0) {
+    switch (color_metadata.colorPrimaries) {
+      case ColorPrimaries_BT709_5:
+        *color_space = HAL_CSC_ITU_R_709;
+        break;
+      case ColorPrimaries_BT601_6_525:
+      case ColorPrimaries_BT601_6_625:
+        *color_space = ((color_metadata.range) ? HAL_CSC_ITU_R_601_FR : HAL_CSC_ITU_R_601);
+        break;
+      case ColorPrimaries_BT2020:
+        *color_space = (color_metadata.range) ? HAL_CSC_ITU_R_2020_FR : HAL_CSC_ITU_R_2020;
+        break;
+      default:
+        ALOGE("Unknown Color Space = %d", color_metadata.colorPrimaries);
+        break;
+    }
+  } else if (getMetaData(hnd, GET_COLOR_SPACE, color_space) != 0) {
+    *color_space = 0;
+  }
+}
+
 void GetAlignedWidthAndHeight(const BufferInfo &info, unsigned int *alignedw,
                               unsigned int *alignedh) {
   int width = info.width;
   int height = info.height;
   int format = info.format;
-  gralloc1_producer_usage_t prod_usage = info.prod_usage;
-  gralloc1_consumer_usage_t cons_usage = info.cons_usage;
+  uint64_t usage = info.usage;
 
   // Currently surface padding is only computed for RGB* surfaces.
-  bool ubwc_enabled = IsUBwcEnabled(format, prod_usage, cons_usage);
+  bool ubwc_enabled = IsUBwcEnabled(format, usage);
   int tile = ubwc_enabled;
 
   if (IsUncompressedRGBFormat(format)) {
@@ -816,8 +855,8 @@
   *alignedh = (unsigned int)aligned_h;
 }
 
-int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4],
-                    uint32_t offset[4], uint32_t *num_planes) {
+int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4], uint32_t offset[4],
+                    uint32_t *num_planes) {
   if (!hnd || !stride || !offset || !num_planes) {
     return -EINVAL;
   }
@@ -904,4 +943,4 @@
   return 0;
 }
 
-}  // namespace gralloc1
+}  // namespace gralloc
diff --git a/libgralloc1/gr_utils.h b/gralloc/gr_utils.h
similarity index 76%
rename from libgralloc1/gr_utils.h
rename to gralloc/gr_utils.h
index 7fcb6c2..fe4fcf8 100644
--- a/libgralloc1/gr_utils.h
+++ b/gralloc/gr_utils.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011-2016, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2011-2016,2018, 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
@@ -30,6 +30,7 @@
 #ifndef __GR_UTILS_H__
 #define __GR_UTILS_H__
 
+#include <android/hardware/graphics/common/1.0/types.h>
 #include "gralloc_priv.h"
 
 #define SZ_2M 0x200000
@@ -37,22 +38,28 @@
 #define SZ_4K 0x1000
 
 #define SIZE_4K 4096
-#define SIZE_8K 4096
+#define SIZE_8K 8192
+
+#ifdef MASTER_SIDE_CP
+#define SECURE_ALIGN SZ_4K
+#else
+#define SECURE_ALIGN SZ_1M
+#endif
 
 #define INT(exp) static_cast<int>(exp)
 #define UINT(exp) static_cast<unsigned int>(exp)
 
-namespace gralloc1 {
+using android::hardware::graphics::common::V1_0::BufferUsage;
 
+namespace gralloc {
 struct BufferInfo {
-  BufferInfo(int w, int h, int f, gralloc1_producer_usage_t prod = GRALLOC1_PRODUCER_USAGE_NONE,
-             gralloc1_consumer_usage_t cons = GRALLOC1_CONSUMER_USAGE_NONE) : width(w), height(h),
-    format(f), prod_usage(prod), cons_usage(cons) {}
+  BufferInfo(int w, int h, int f, uint64_t usage = 0)
+      : width(w), height(h), format(f), layer_count(1), usage(usage) {}
   int width;
   int height;
   int format;
-  gralloc1_producer_usage_t prod_usage;
-  gralloc1_consumer_usage_t cons_usage;
+  int layer_count;
+  uint64_t usage;
 };
 
 template <class Type1, class Type2>
@@ -64,20 +71,21 @@
 bool IsCompressedRGBFormat(int format);
 bool IsUncompressedRGBFormat(int format);
 uint32_t GetBppForUncompressedRGB(int format);
-bool CpuCanAccess(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage);
-bool CpuCanRead(gralloc1_producer_usage_t prod_usage, gralloc1_consumer_usage_t cons_usage);
-bool CpuCanWrite(gralloc1_producer_usage_t prod_usage);
+bool CpuCanAccess(uint64_t usage);
+bool CpuCanRead(uint64_t usage);
+bool CpuCanWrite(uint64_t usage);
 unsigned int GetSize(const BufferInfo &d, unsigned int alignedw, unsigned int alignedh);
-void GetBufferSizeAndDimensions(const BufferInfo &d, unsigned int *size,
-                                unsigned int *alignedw, unsigned int *alignedh);
+void GetBufferSizeAndDimensions(const BufferInfo &d, unsigned int *size, unsigned int *alignedw,
+                                unsigned int *alignedh);
+void GetCustomDimensions(private_handle_t *hnd, int *stride, int *height);
+void GetColorSpaceFromMetadata(private_handle_t *hnd, int *color_space);
 void GetAlignedWidthAndHeight(const BufferInfo &d, unsigned int *aligned_w,
                               unsigned int *aligned_h);
 int GetYUVPlaneInfo(const private_handle_t *hnd, struct android_ycbcr ycbcr[2]);
 int GetRgbDataAddress(private_handle_t *hnd, void **rgb_data);
 bool IsUBwcFormat(int format);
 bool IsUBwcSupported(int format);
-bool IsUBwcEnabled(int format, gralloc1_producer_usage_t prod_usage,
-                   gralloc1_consumer_usage_t cons_usage);
+bool IsUBwcEnabled(int format, uint64_t usage);
 void GetYuvUBwcWidthAndHeight(int width, int height, int format, unsigned int *aligned_w,
                               unsigned int *aligned_h);
 void GetYuvSPPlaneInfo(uint64_t base, uint32_t width, uint32_t height, uint32_t bpp,
@@ -90,8 +98,10 @@
 unsigned int GetRgbUBwcMetaBufferSize(int width, int height, uint32_t bpp);
 unsigned int GetUBwcSize(int width, int height, int format, unsigned int alignedw,
                          unsigned int alignedh);
-int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4],
-                    uint32_t offset[4], uint32_t *num_planes);
-}  // namespace gralloc1
+int GetBufferLayout(private_handle_t *hnd, uint32_t stride[4], uint32_t offset[4],
+                    uint32_t *num_planes);
+uint32_t GetDataAlignment(int format, uint64_t usage);
+
+}  // namespace gralloc
 
 #endif  // __GR_UTILS_H__
diff --git a/libgralloc1/gralloc_priv.h b/gralloc/gralloc_priv.h
similarity index 71%
rename from libgralloc1/gralloc_priv.h
rename to gralloc/gralloc_priv.h
index 07cc285..7f084a0 100644
--- a/libgralloc1/gralloc_priv.h
+++ b/gralloc/gralloc_priv.h
@@ -26,68 +26,53 @@
 
 #define ROUND_UP_PAGESIZE(x) roundUpToPageSize(x)
 inline int roundUpToPageSize(int x) {
-    return (x + (getpagesize()-1)) & ~(getpagesize()-1);
+  return (x + (getpagesize() - 1)) & ~(getpagesize() - 1);
 }
 
 /* Gralloc usage bits indicating the type of allocation that should be used */
-/* Refer gralloc1_producer_usage_t & gralloc1_consumer_usage-t in gralloc1.h */
+/* Refer to BufferUsage in hardware/interfaces/graphics/common/<ver>/types.hal */
 
-/* Producer flags */
+/* The bits below are in officially defined vendor space
+ * i.e bits 28-31 and 48-63*/
 /* Non linear, Universal Bandwidth Compression */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC  GRALLOC1_PRODUCER_USAGE_PRIVATE_0
+#define GRALLOC_USAGE_PRIVATE_ALLOC_UBWC 1 << 28
 
 /* Set this for allocating uncached memory (using O_DSYNC),
  * cannot be used with noncontiguous heaps */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_UNCACHED    GRALLOC1_PRODUCER_USAGE_PRIVATE_1
+#define GRALLOC_USAGE_PRIVATE_UNCACHED 1 << 29
 
 /* This flag is used to indicate P010 format */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT       GRALLOC1_PRODUCER_USAGE_PRIVATE_2
-
-/* ADSP heap is a carveout heap, is not secured */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_ADSP_HEAP   GRALLOC1_PRODUCER_USAGE_PRIVATE_3
-
-/* IOMMU heap comes from manually allocated pages, can be cached/uncached, is not secured */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_IOMMU_HEAP  GRALLOC1_PRODUCER_USAGE_PRIVATE_4
-
-/* MM heap is a carveout heap for video, can be secured */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_MM_HEAP     GRALLOC1_PRODUCER_USAGE_PRIVATE_5
-
-/* Use legacy ZSL definition until we know the correct usage on gralloc1 */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_CAMERA_ZSL  GRALLOC_USAGE_HW_CAMERA_ZSL
-
-/* TODO(user): move these to use producer private bits once 64-bit support available */
-/* This flag is used to indicate 10-bit tight pack format (e.g. TP10) */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT_TP  0x08000000
-#define GRALLOC1_CONSUMER_USAGE_PRIVATE_10BIT_TP  0x08000000
-
-/* This flag is used to indicate video NV21 format */
-#define GRALLOC1_PRODUCER_USAGE_PRIVATE_VIDEO_NV21_ENCODER (1ULL << 24)
-
-/* Consumer flags */
-/* TODO(user): Fix when producer and consumer flags are actually separated */
-/* This flag is set for WFD usecase */
-#define GRALLOC1_CONSUMER_USAGE_PRIVATE_WFD            0x00200000
+#define GRALLOC_USAGE_PRIVATE_10BIT 1 << 30
 
 /* This flag is used for SECURE display usecase */
-#define GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY 0x02000000
+#define GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY 1 << 31
 
-/* This flag is used to indicate P010 format */
-#define GRALLOC1_CONSUMER_USAGE_PRIVATE_10BIT       GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT
+/* This flag is used to indicate video NV21 format */
+#define GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER 1ULL << 48
 
-/* Unused flag */
-#define GRALLOC1_USAGE_PRIVATE_UNUSED1  0x04000000
+/* unused legacy flags */
+#define GRALLOC_USAGE_PRIVATE_MM_HEAP 0
+#define GRALLOC_USAGE_PRIVATE_IOMMU_HEAP 0
 
+/* TODO(user): move these to use sanctioned vendor bits
+ * once end to end 64-bit support is available */
+/* This flag is set for WFD usecase */
+#define GRALLOC_USAGE_PRIVATE_WFD 1 << 21
 
-/* Legacy gralloc0.x definitions */
+/* This flag is used to indicate 10-bit tight pack format (e.g. TP10) */
+#define GRALLOC_USAGE_PRIVATE_10BIT_TP 1 << 27
+
+/* Legacy gralloc1 definitions */
 /* Some clients may still be using the old flags */
-#define GRALLOC_USAGE_PRIVATE_ALLOC_UBWC GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC
-#define GRALLOC_USAGE_PRIVATE_UNCACHED GRALLOC1_PRODUCER_USAGE_PRIVATE_UNCACHED
-#define GRALLOC_USAGE_PRIVATE_IOMMU_HEAP GRALLOC1_PRODUCER_USAGE_PRIVATE_IOMMU_HEAP
-#define GRALLOC_USAGE_PRIVATE_WFD GRALLOC1_CONSUMER_USAGE_PRIVATE_WFD
-#define GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY
-#define GRALLOC_USAGE_PRIVATE_MM_HEAP 0x0
-
-
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_ADSP_HEAP GRALLOC_USAGE_PRIVATE_ADSP_HEAP
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_ALLOC_UBWC GRALLOC_USAGE_PRIVATE_ALLOC_UBWC
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_UNCACHED GRALLOC_USAGE_PRIVATE_UNCACHED
+#define GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_MM_HEAP GRALLOC_USAGE_PRIVATE_MM_HEAP
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT GRALLOC_USAGE_PRIVATE_10BIT
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_10BIT_TP GRALLOC_USAGE_PRIVATE_10BIT_TP
+#define GRALLOC1_CONSUMER_USAGE_PRIVATE_10BIT_TP GRALLOC_USAGE_PRIVATE_10BIT_TP
+#define GRALLOC1_PRODUCER_USAGE_PRIVATE_VIDEO_NV21_ENCODER GRALLOC_USAGE_PRIVATE_VIDEO_NV21_ENCODER
 
 // for PERFORM API :
 #define GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER 1
@@ -139,8 +124,8 @@
 #define HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC 0x124
 #define HAL_PIXEL_FORMAT_YCbCr_420_P010_VENUS 0x7FA30C0A
 
-#define HAL_PIXEL_FORMAT_CbYCrY_422_I            0x120
-#define HAL_PIXEL_FORMAT_BGR_888                 0x121
+#define HAL_PIXEL_FORMAT_CbYCrY_422_I 0x120
+#define HAL_PIXEL_FORMAT_BGR_888 0x121
 
 #define HAL_PIXEL_FORMAT_INTERLACE 0x180
 
@@ -153,7 +138,7 @@
 
 // UBWC aligned Venus format
 #define HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC 0x7FA30C06
-#define HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC     0x7FA30C09
+#define HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC 0x7FA30C09
 
 // Khronos ASTC formats
 #define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93B0
@@ -190,11 +175,11 @@
 #define HAL_IGC_s_RGB 1
 
 /* Color Space: Values maps to ColorSpace_t in qdMetadata.h */
-#define HAL_CSC_ITU_R_601         0
-#define HAL_CSC_ITU_R_601_FR      1
-#define HAL_CSC_ITU_R_709         2
-#define HAL_CSC_ITU_R_2020        3
-#define HAL_CSC_ITU_R_2020_FR     4
+#define HAL_CSC_ITU_R_601 0
+#define HAL_CSC_ITU_R_601_FR 1
+#define HAL_CSC_ITU_R_709 2
+#define HAL_CSC_ITU_R_2020 3
+#define HAL_CSC_ITU_R_2020_FR 4
 
 /* possible formats for 3D content*/
 enum {
diff --git a/gralloc/service.cpp b/gralloc/service.cpp
new file mode 100644
index 0000000..b19cc88
--- /dev/null
+++ b/gralloc/service.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2018, 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
+ * met:
+ *    * Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *    * Redistributions in binary form must reproduce the above
+ *      copyright notice, this list of conditions and the following
+ *      disclaimer in the documentation and/or other materials provided
+ *      with the distribution.
+ *    * Neither the name of The Linux Foundation. nor the names of its
+ *      contributors may be used to endorse or promote products derived
+ *      from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+#include <binder/ProcessState.h>
+#include <hidl/LegacySupport.h>
+#include "QtiAllocator.h"
+
+using android::hardware::configureRpcThreadpool;
+using android::hardware::joinRpcThreadpool;
+using vendor::qti::hardware::display::allocator::V1_0::implementation::QtiAllocator;
+using android::hardware::graphics::allocator::V2_0::IAllocator;
+
+int main(int, char **) {
+  android::sp<IAllocator> service = new QtiAllocator();
+  configureRpcThreadpool(4, true /*callerWillJoin*/);
+  if (service->registerAsService() != android::OK) {
+    ALOGE("Cannot register QTI Allocator service");
+    return -EINVAL;
+  }
+  ALOGI("Initialized qti-allocator");
+  joinRpcThreadpool();
+  return 0;
+}
diff --git a/gralloc/vendor.qti.hardware.display.allocator@1.0-service.rc b/gralloc/vendor.qti.hardware.display.allocator@1.0-service.rc
new file mode 100644
index 0000000..07bb2ff
--- /dev/null
+++ b/gralloc/vendor.qti.hardware.display.allocator@1.0-service.rc
@@ -0,0 +1,6 @@
+service vendor.qti.hardware.display.allocator /vendor/bin/hw/vendor.qti.hardware.display.allocator@1.0-service
+    class hal animation
+    user system
+    group graphics drmrpc
+    capabilities SYS_NICE
+    onrestart restart surfaceflinger
diff --git a/hdmi_cec/qhdmi_cec.cpp b/hdmi_cec/qhdmi_cec.cpp
index 0923d92..2760334 100644
--- a/hdmi_cec/qhdmi_cec.cpp
+++ b/hdmi_cec/qhdmi_cec.cpp
@@ -30,7 +30,7 @@
 #define DEBUG 0
 #define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
 #include <cstdlib>
-#include <cutils/log.h>
+#include <log/log.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <hardware/hdmi_cec.h>
diff --git a/include/Android.mk b/include/Android.mk
index 5b1d05d..b00416b 100644
--- a/include/Android.mk
+++ b/include/Android.mk
@@ -20,6 +20,7 @@
                                  $(display_top)/libqservice \
                                  $(display_top)/gpu_tonemapper \
                                  $(display_top)/sdm/include \
+                                 $(display_top)/gralloc \
                                  $(display_top)/libgralloc1
 
 include $(BUILD_HEADER_LIBRARY)
diff --git a/libcopybit/copybit.cpp b/libcopybit/copybit.cpp
index 80b3cfe..bd49edc 100644
--- a/libcopybit/copybit.cpp
+++ b/libcopybit/copybit.cpp
@@ -18,7 +18,7 @@
  * limitations under the License.
  */
 
-#include <cutils/log.h>
+#include <log/log.h>
 
 #include <linux/msm_mdp.h>
 #include <linux/fb.h>
diff --git a/libcopybit/copybit_c2d.cpp b/libcopybit/copybit_c2d.cpp
index 240ba26..63c1379 100644
--- a/libcopybit/copybit_c2d.cpp
+++ b/libcopybit/copybit_c2d.cpp
@@ -17,7 +17,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include <cutils/log.h>
+#include <log/log.h>
 #include <sys/resource.h>
 #include <sys/prctl.h>
 
diff --git a/libcopybit/software_converter.cpp b/libcopybit/software_converter.cpp
index e5c03b5..1aa3ce6 100644
--- a/libcopybit/software_converter.cpp
+++ b/libcopybit/software_converter.cpp
@@ -27,7 +27,7 @@
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include <cutils/log.h>
+#include <log/log.h>
 #include <stdlib.h>
 #include <errno.h>
 #include "software_converter.h"
diff --git a/libgralloc/gralloc_priv.h b/libgralloc/gralloc_priv.h
deleted file mode 100644
index f0c6b4d..0000000
--- a/libgralloc/gralloc_priv.h
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- * Copyright (c) 2011 - 2017, The Linux Foundation. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef GRALLOC_PRIV_H_
-#define GRALLOC_PRIV_H_
-
-#include <stdint.h>
-#include <limits.h>
-#include <sys/cdefs.h>
-#include <hardware/gralloc.h>
-#include <pthread.h>
-#include <errno.h>
-#include <unistd.h>
-
-
-/* DEPRECATION NOTICE: This file is no longer used, please use the new
- * implementation in libgralloc1
- */
-
-
-
-
-#include <cutils/native_handle.h>
-
-#include <cutils/log.h>
-
-#define ROUND_UP_PAGESIZE(x) (unsigned int)( ((x) + getpagesize()-1)  & \
-                                             (~(getpagesize()-1)) )
-
-/* Gralloc usage bits indicating the type of allocation that should be used */
-/* SYSTEM heap comes from kernel vmalloc (ION_SYSTEM_HEAP_ID)
- * is cached by default and
- * is not secured */
-
-/* GRALLOC_USAGE_PRIVATE_0 is unused */
-
-/* Non linear, Universal Bandwidth Compression */
-#define GRALLOC_USAGE_PRIVATE_ALLOC_UBWC      GRALLOC_USAGE_PRIVATE_1
-
-/* IOMMU heap comes from manually allocated pages, can be cached/uncached,
- * is not secured */
-#define GRALLOC_USAGE_PRIVATE_IOMMU_HEAP      GRALLOC_USAGE_PRIVATE_2
-
-/* MM heap is a carveout heap for video, can be secured */
-#define GRALLOC_USAGE_PRIVATE_MM_HEAP         GRALLOC_USAGE_PRIVATE_3
-
-/* ADSP heap is a carveout heap, is not secured */
-#define GRALLOC_USAGE_PRIVATE_ADSP_HEAP       0x01000000
-
-/* Set this for allocating uncached memory (using O_DSYNC),
- * cannot be used with noncontiguous heaps */
-#define GRALLOC_USAGE_PRIVATE_UNCACHED        0x02000000
-
-/* Buffer content should be displayed on an primary display only */
-#define GRALLOC_USAGE_PRIVATE_INTERNAL_ONLY   0x04000000
-
-/* Buffer content should be displayed on an external display only */
-#define GRALLOC_USAGE_PRIVATE_EXTERNAL_ONLY   0x08000000
-
-/* This flag is set for WFD usecase */
-#define GRALLOC_USAGE_PRIVATE_WFD             0x00200000
-
-/* CAMERA heap is a carveout heap for camera, is not secured */
-#define GRALLOC_USAGE_PRIVATE_CAMERA_HEAP     0x00400000
-
-/* This flag is used for SECURE display usecase */
-#define GRALLOC_USAGE_PRIVATE_SECURE_DISPLAY  0x00800000
-
-/* define Gralloc perform */
-#define GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER 1
-// This will be used by the graphics drivers to know if certain features
-// are defined in this display HAL.
-// Ex: Newer GFX libraries + Older Display HAL
-#define GRALLOC_MODULE_PERFORM_GET_STRIDE 2
-#define GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE 3
-#define GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE 4
-#define GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES 5
-#define GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE 6
-#define GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO 7
-#define GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO 8
-#define GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG 9
-#define GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS 10
-#define GRALLOC_MODULE_PERFORM_GET_IGC 11
-#define GRALLOC_MODULE_PERFORM_SET_IGC 12
-#define GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE 13
-
-/* OEM specific HAL formats */
-
-#define HAL_PIXEL_FORMAT_RGBA_5551               6
-#define HAL_PIXEL_FORMAT_RGBA_4444               7
-#define HAL_PIXEL_FORMAT_NV12_ENCODEABLE         0x102
-#define HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS      0x7FA30C04
-#define HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED      0x7FA30C03
-#define HAL_PIXEL_FORMAT_YCbCr_420_SP            0x109
-#define HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO     0x7FA30C01
-#define HAL_PIXEL_FORMAT_YCrCb_422_SP            0x10B
-#define HAL_PIXEL_FORMAT_R_8                     0x10D
-#define HAL_PIXEL_FORMAT_RG_88                   0x10E
-#define HAL_PIXEL_FORMAT_YCbCr_444_SP            0x10F
-#define HAL_PIXEL_FORMAT_YCrCb_444_SP            0x110
-#define HAL_PIXEL_FORMAT_YCrCb_422_I             0x111
-#define HAL_PIXEL_FORMAT_BGRX_8888               0x112
-#define HAL_PIXEL_FORMAT_NV21_ZSL                0x113
-#define HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS      0x114
-#define HAL_PIXEL_FORMAT_BGR_565                 0x115
-#define HAL_PIXEL_FORMAT_RGBA_1010102            0x116
-#define HAL_PIXEL_FORMAT_ARGB_2101010            0x117
-#define HAL_PIXEL_FORMAT_RGBX_1010102            0x118
-#define HAL_PIXEL_FORMAT_XRGB_2101010            0x119
-#define HAL_PIXEL_FORMAT_BGRA_1010102            0x11A
-#define HAL_PIXEL_FORMAT_ABGR_2101010            0x11B
-#define HAL_PIXEL_FORMAT_BGRX_1010102            0x11C
-#define HAL_PIXEL_FORMAT_XBGR_2101010            0x11D
-#define HAL_PIXEL_FORMAT_YCbCr_420_P010          0x11F
-#define HAL_PIXEL_FORMAT_CbYCrY_422_I            0x120
-#define HAL_PIXEL_FORMAT_BGR_888                 0x121
-#define HAL_PIXEL_FORMAT_RAW8                    0x123
-#define HAL_PIXEL_FORMAT_YCbCr_420_P010_UBWC     0x124
-
-#define HAL_PIXEL_FORMAT_INTERLACE               0x180
-
-//v4l2_fourcc('Y', 'U', 'Y', 'L'). 24 bpp YUYV 4:2:2 10 bit per component
-#define HAL_PIXEL_FORMAT_YCbCr_422_I_10BIT       0x4C595559
-
-//v4l2_fourcc('Y', 'B', 'W', 'C'). 10 bit per component. This compressed
-//format reduces the memory access bandwidth
-#define HAL_PIXEL_FORMAT_YCbCr_422_I_10BIT_COMPRESSED  0x43574259
-
-// UBWC aligned Venus format
-#define HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS_UBWC 0x7FA30C06
-#define HAL_PIXEL_FORMAT_YCbCr_420_TP10_UBWC     0x7FA30C09
-
-//Khronos ASTC formats
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_4x4_KHR             0x93B0
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x4_KHR             0x93B1
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_5x5_KHR             0x93B2
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x5_KHR             0x93B3
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_6x6_KHR             0x93B4
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x5_KHR             0x93B5
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x6_KHR             0x93B6
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_8x8_KHR             0x93B7
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x5_KHR            0x93B8
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x6_KHR            0x93B9
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x8_KHR            0x93BA
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_10x10_KHR           0x93BB
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x10_KHR           0x93BC
-#define HAL_PIXEL_FORMAT_COMPRESSED_RGBA_ASTC_12x12_KHR           0x93BD
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR     0x93D0
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR     0x93D1
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR     0x93D2
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR     0x93D3
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR     0x93D4
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR     0x93D5
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR     0x93D6
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR     0x93D7
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR    0x93D8
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR    0x93D9
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR    0x93DA
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR   0x93DB
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR   0x93DC
-#define HAL_PIXEL_FORMAT_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR   0x93DD
-
-/* possible values for inverse gamma correction */
-#define HAL_IGC_NOT_SPECIFIED     0
-#define HAL_IGC_s_RGB             1
-
-/* Color Space: Values maps to ColorSpace_t in qdMetadata.h */
-#define HAL_CSC_ITU_R_601         0
-#define HAL_CSC_ITU_R_601_FR      1
-#define HAL_CSC_ITU_R_709         2
-#define HAL_CSC_ITU_R_2020        3
-#define HAL_CSC_ITU_R_2020_FR     4
-
-/* possible formats for 3D content*/
-enum {
-    HAL_NO_3D                      = 0x0,
-    HAL_3D_SIDE_BY_SIDE_L_R        = 0x1,
-    HAL_3D_SIDE_BY_SIDE_R_L        = 0x2,
-    HAL_3D_TOP_BOTTOM              = 0x4,
-    HAL_3D_IN_SIDE_BY_SIDE_L_R     = 0x10000, //unused legacy format
-};
-
-enum {
-    BUFFER_TYPE_UI = 0,
-    BUFFER_TYPE_VIDEO
-};
-
-#ifdef __cplusplus
-struct private_handle_t : public native_handle {
-#else
-    struct private_handle_t {
-        native_handle_t nativeHandle;
-#endif
-        enum {
-            PRIV_FLAGS_FRAMEBUFFER        = 0x00000001,
-            PRIV_FLAGS_USES_ION           = 0x00000008,
-            PRIV_FLAGS_USES_ASHMEM        = 0x00000010,
-            PRIV_FLAGS_NEEDS_FLUSH        = 0x00000020,
-            PRIV_FLAGS_INTERNAL_ONLY      = 0x00000040,
-            PRIV_FLAGS_NON_CPU_WRITER     = 0x00000080,
-            PRIV_FLAGS_NONCONTIGUOUS_MEM  = 0x00000100,
-            PRIV_FLAGS_CACHED             = 0x00000200,
-            PRIV_FLAGS_SECURE_BUFFER      = 0x00000400,
-            // Display on external only
-            PRIV_FLAGS_EXTERNAL_ONLY      = 0x00002000,
-            // Set by HWC for protected non secure buffers
-            PRIV_FLAGS_PROTECTED_BUFFER   = 0x00004000,
-            PRIV_FLAGS_VIDEO_ENCODER      = 0x00010000,
-            PRIV_FLAGS_CAMERA_WRITE       = 0x00020000,
-            PRIV_FLAGS_CAMERA_READ        = 0x00040000,
-            PRIV_FLAGS_HW_COMPOSER        = 0x00080000,
-            PRIV_FLAGS_HW_TEXTURE         = 0x00100000,
-            PRIV_FLAGS_ITU_R_601          = 0x00200000, //Unused from display
-            PRIV_FLAGS_ITU_R_601_FR       = 0x00400000, //Unused from display
-            PRIV_FLAGS_ITU_R_709          = 0x00800000, //Unused from display
-            PRIV_FLAGS_SECURE_DISPLAY     = 0x01000000,
-            // Buffer is rendered in Tile Format
-            PRIV_FLAGS_TILE_RENDERED      = 0x02000000,
-            // Buffer rendered using CPU/SW renderer
-            PRIV_FLAGS_CPU_RENDERED       = 0x04000000,
-            // Buffer is allocated with UBWC alignment
-            PRIV_FLAGS_UBWC_ALIGNED       = 0x08000000,
-            // Buffer allocated will be consumed by SF/HWC
-            PRIV_FLAGS_DISP_CONSUMER      = 0x10000000
-        };
-
-        // file-descriptors
-        int     fd;
-        int     fd_metadata;          // fd for the meta-data
-        // ints
-        int     magic;
-        int     flags;
-        unsigned int  size;
-        unsigned int  offset;
-        int     bufferType;
-        uint64_t base __attribute__((aligned(8)));
-        unsigned int  offset_metadata;
-        // The gpu address mapped into the mmu.
-        uint64_t gpuaddr __attribute__((aligned(8)));
-        int     format;
-        int     width;   // holds aligned width of the actual buffer allocated
-        int     height;  // holds aligned height of the  actual buffer allocated
-        uint64_t base_metadata __attribute__((aligned(8)));
-        int unaligned_width;   // holds width client asked to allocate
-        int unaligned_height;  // holds height client asked to allocate
-
-#ifdef __cplusplus
-        static const int sNumFds = 2;
-        static inline int sNumInts() {
-            return ((sizeof(private_handle_t) - sizeof(native_handle_t)) /
-                    sizeof(int)) - sNumFds;
-        }
-        static const int sMagic = 'gmsm';
-
-        private_handle_t(int fd, unsigned int size, int flags, int bufferType,
-                int format, int width, int height) :
-            fd(fd), fd_metadata(-1), magic(sMagic),
-            flags(flags), size(size), offset(0), bufferType(bufferType),
-            base(0), offset_metadata(0), gpuaddr(0),
-            format(format), width(width), height(height),
-            base_metadata(0), unaligned_width(width),
-            unaligned_height(height)
-        {
-            version = (int) sizeof(native_handle);
-            numInts = sNumInts();
-            numFds = sNumFds;
-        }
-
-        private_handle_t(int fd, unsigned int size, int flags, int bufferType,
-                int format, int width, int height,
-                int eFd, unsigned int eOffset, uint64_t eBase) :
-            private_handle_t(fd, size, flags, bufferType, format, width, height)
-        {
-            fd_metadata = eFd;
-            offset_metadata = eOffset;
-            base_metadata = eBase;
-        }
-
-        private_handle_t(int fd, unsigned int size, int flags, int bufferType,
-                int format, int width, int height,
-                int eFd, unsigned int eOffset, uint64_t eBase,
-                int unaligned_w, int unaligned_h) :
-            private_handle_t(fd, size, flags, bufferType, format, width, height,
-                    eFd, eOffset, eBase)
-        {
-            unaligned_width = unaligned_w;
-            unaligned_height = unaligned_h;
-        }
-
-        ~private_handle_t() {
-            magic = 0;
-        }
-
-        static int validate(const native_handle* h) {
-            const private_handle_t* hnd = (const private_handle_t*)h;
-            if (!h || h->version != sizeof(native_handle) ||
-                h->numInts != sNumInts() || h->numFds != sNumFds ||
-                hnd->magic != sMagic)
-            {
-                ALOGD("Invalid gralloc handle (at %p): "
-                      "ver(%d/%zu) ints(%d/%d) fds(%d/%d)"
-                      "magic(%c%c%c%c/%c%c%c%c)",
-                      h,
-                      h ? h->version : -1, sizeof(native_handle),
-                      h ? h->numInts : -1, sNumInts(),
-                      h ? h->numFds : -1, sNumFds,
-                      hnd ? (((hnd->magic >> 24) & 0xFF)?
-                             ((hnd->magic >> 24) & 0xFF) : '-') : '?',
-                      hnd ? (((hnd->magic >> 16) & 0xFF)?
-                             ((hnd->magic >> 16) & 0xFF) : '-') : '?',
-                      hnd ? (((hnd->magic >> 8) & 0xFF)?
-                             ((hnd->magic >> 8) & 0xFF) : '-') : '?',
-                      hnd ? (((hnd->magic >> 0) & 0xFF)?
-                             ((hnd->magic >> 0) & 0xFF) : '-') : '?',
-                      (sMagic >> 24) & 0xFF,
-                      (sMagic >> 16) & 0xFF,
-                      (sMagic >> 8) & 0xFF,
-                      (sMagic >> 0) & 0xFF);
-                return -EINVAL;
-            }
-            return 0;
-        }
-
-        static private_handle_t* dynamicCast(const native_handle* in) {
-            if (validate(in) == 0) {
-                return (private_handle_t*) in;
-            }
-            return NULL;
-        }
-#endif
-    };
-
-#endif /* GRALLOC_PRIV_H_ */
diff --git a/libgralloc1/Android.mk b/libgralloc1/Android.mk
deleted file mode 100644
index 49ceae5..0000000
--- a/libgralloc1/Android.mk
+++ /dev/null
@@ -1,40 +0,0 @@
-# Gralloc module
-LOCAL_PATH := $(call my-dir)
-include $(LOCAL_PATH)/../common.mk
-include $(CLEAR_VARS)
-
-LOCAL_MODULE                  := gralloc.$(TARGET_BOARD_PLATFORM)
-LOCAL_VENDOR_MODULE           := true
-LOCAL_MODULE_RELATIVE_PATH    := hw
-LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes) \
-                                 external/libcxx/include/ \
-                                 system/core/libion/include/ \
-                                 system/core/libion/kernel-headers/ \
-                                 $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
-
-LOCAL_HEADER_LIBRARIES        := display_headers
-LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdMetaData libsync libgrallocutils libion
-LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"qdgralloc\" -Wall -std=c++11 -Werror
-LOCAL_CLANG                   := true
-LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
-LOCAL_SRC_FILES               := gr_ion_alloc.cpp \
-                                 gr_allocator.cpp \
-                                 gr_buf_mgr.cpp \
-                                 gr_device_impl.cpp
-LOCAL_COPY_HEADERS_TO         := $(common_header_export_path)
-LOCAL_COPY_HEADERS            := gr_device_impl.h gralloc_priv.h gr_priv_handle.h
-include $(BUILD_SHARED_LIBRARY)
-
-#libgrallocutils
-include $(CLEAR_VARS)
-LOCAL_MODULE                  := libgrallocutils
-LOCAL_VENDOR_MODULE           := true
-LOCAL_MODULE_TAGS             := optional
-LOCAL_C_INCLUDES              := $(common_includes) $(kernel_includes)
-LOCAL_HEADER_LIBRARIES        := display_headers
-LOCAL_SHARED_LIBRARIES        := $(common_libs) libqdMetaData libdl
-LOCAL_CFLAGS                  := $(common_flags) -DLOG_TAG=\"grallocutils\" -Wno-sign-conversion
-LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) $(kernel_deps)
-LOCAL_SRC_FILES               := gr_utils.cpp gr_adreno_info.cpp
-include $(BUILD_SHARED_LIBRARY)
diff --git a/libgralloc1/gr_buf_descriptor.h b/libgralloc1/gr_buf_descriptor.h
deleted file mode 100644
index c909fa4..0000000
--- a/libgralloc1/gr_buf_descriptor.h
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2016-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
- * met:
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of The Linux Foundation nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __GR_BUF_DESCRIPTOR_H__
-#define __GR_BUF_DESCRIPTOR_H__
-
-#include <hardware/gralloc1.h>
-#include <atomic>
-
-namespace gralloc1 {
-class BufferDescriptor {
- public:
-  BufferDescriptor() : id_(next_id_++) {}
-
-  BufferDescriptor(int w, int h, int f)
-      : width_(w),
-        height_(h),
-        format_(f),
-        producer_usage_(GRALLOC1_PRODUCER_USAGE_NONE),
-        consumer_usage_(GRALLOC1_CONSUMER_USAGE_NONE),
-        id_(next_id_++) {}
-
-  BufferDescriptor(int w, int h, int f, gralloc1_producer_usage_t prod_usage,
-                   gralloc1_consumer_usage_t cons_usage)
-      : width_(w),
-        height_(h),
-        format_(f),
-        producer_usage_(prod_usage),
-        consumer_usage_(cons_usage),
-        id_(next_id_++) {}
-
-  void SetConsumerUsage(gralloc1_consumer_usage_t usage) { consumer_usage_ = usage; }
-
-  void SetProducerUsage(gralloc1_producer_usage_t usage) { producer_usage_ = usage; }
-
-  void SetDimensions(int w, int h) {
-    width_ = w;
-    height_ = h;
-  }
-
-  void SetColorFormat(int format) { format_ = format; }
-
-  void SetLayerCount(uint32_t layer_count) { layer_count_ = layer_count; }
-
-  gralloc1_consumer_usage_t GetConsumerUsage() const { return consumer_usage_; }
-
-  gralloc1_producer_usage_t GetProducerUsage() const { return producer_usage_; }
-
-  int GetWidth() const { return width_; }
-
-  int GetHeight() const { return height_; }
-
-  int GetFormat() const { return format_; }
-
-  uint32_t GetLayerCount() const { return layer_count_; }
-
-  gralloc1_buffer_descriptor_t GetId() const { return id_; }
-
- private:
-  int width_ = -1;
-  int height_ = -1;
-  int format_ = -1;
-  uint32_t layer_count_ = 1;
-  gralloc1_producer_usage_t producer_usage_ = GRALLOC1_PRODUCER_USAGE_NONE;
-  gralloc1_consumer_usage_t consumer_usage_ = GRALLOC1_CONSUMER_USAGE_NONE;
-  const gralloc1_buffer_descriptor_t id_;
-  static std::atomic<gralloc1_buffer_descriptor_t> next_id_;
-};
-};  // namespace gralloc1
-#endif  // __GR_BUF_DESCRIPTOR_H__
diff --git a/libgralloc1/gr_buf_mgr.cpp b/libgralloc1/gr_buf_mgr.cpp
deleted file mode 100644
index 8a1403a..0000000
--- a/libgralloc1/gr_buf_mgr.cpp
+++ /dev/null
@@ -1,909 +0,0 @@
-/*
- * Copyright (c) 2011-2018 The Linux Foundation. All rights reserved.
- * Not a Contribution
- *
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#define DEBUG 0
-
-#include <iomanip>
-#include <utility>
-#include <vector>
-#include <sstream>
-
-#include "qd_utils.h"
-#include "gr_priv_handle.h"
-#include "gr_buf_descriptor.h"
-#include "gr_utils.h"
-#include "gr_buf_mgr.h"
-#include "qdMetaData.h"
-
-namespace gralloc1 {
-std::atomic<gralloc1_buffer_descriptor_t> BufferDescriptor::next_id_(1);
-
-static BufferInfo GetBufferInfo(const BufferDescriptor &descriptor) {
-  return BufferInfo(descriptor.GetWidth(), descriptor.GetHeight(), descriptor.GetFormat(),
-                    descriptor.GetProducerUsage(), descriptor.GetConsumerUsage());
-}
-
-BufferManager::BufferManager() : next_id_(0) {
-  char property[PROPERTY_VALUE_MAX];
-
-  // Map framebuffer memory
-  if ((property_get("debug.gralloc.map_fb_memory", property, NULL) > 0) &&
-      (!strncmp(property, "1", PROPERTY_VALUE_MAX) ||
-       (!strncasecmp(property, "true", PROPERTY_VALUE_MAX)))) {
-    map_fb_mem_ = true;
-  }
-
-  handles_map_.clear();
-  allocator_ = new Allocator();
-  allocator_->Init();
-}
-
-
-gralloc1_error_t BufferManager::CreateBufferDescriptor(
-    gralloc1_buffer_descriptor_t *descriptor_id) {
-  std::lock_guard<std::mutex> lock(descriptor_lock_);
-  auto descriptor = std::make_shared<BufferDescriptor>();
-  descriptors_map_.emplace(descriptor->GetId(), descriptor);
-  *descriptor_id = descriptor->GetId();
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t BufferManager::DestroyBufferDescriptor(
-    gralloc1_buffer_descriptor_t descriptor_id) {
-  std::lock_guard<std::mutex> lock(descriptor_lock_);
-  const auto descriptor = descriptors_map_.find(descriptor_id);
-  if (descriptor == descriptors_map_.end()) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  }
-  descriptors_map_.erase(descriptor);
-  return GRALLOC1_ERROR_NONE;
-}
-
-BufferManager::~BufferManager() {
-  if (allocator_) {
-    delete allocator_;
-  }
-}
-
-gralloc1_error_t BufferManager::AllocateBuffers(uint32_t num_descriptors,
-                                                const gralloc1_buffer_descriptor_t *descriptor_ids,
-                                                buffer_handle_t *out_buffers) {
-  bool shared = true;
-  gralloc1_error_t status = GRALLOC1_ERROR_NONE;
-
-  // since GRALLOC1_CAPABILITY_TEST_ALLOCATE capability is supported
-  // client can ask to test the allocation by passing NULL out_buffers
-  bool test_allocate = !out_buffers;
-
-  // Validate descriptors
-  std::lock_guard<std::mutex> descriptor_lock(descriptor_lock_);
-  std::vector<std::shared_ptr<BufferDescriptor>> descriptors;
-  for (uint32_t i = 0; i < num_descriptors; i++) {
-    const auto map_descriptor = descriptors_map_.find(descriptor_ids[i]);
-    if (map_descriptor == descriptors_map_.end()) {
-      return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-    } else {
-      descriptors.push_back(map_descriptor->second);
-    }
-  }
-
-  //  Resolve implementation defined formats
-  for (auto &descriptor : descriptors) {
-    descriptor->SetColorFormat(allocator_->GetImplDefinedFormat(descriptor->GetProducerUsage(),
-                                                                descriptor->GetConsumerUsage(),
-                                                                descriptor->GetFormat()));
-  }
-
-  // Check if input descriptors can be supported AND
-  // Find out if a single buffer can be shared for all the given input descriptors
-  uint32_t i = 0;
-  ssize_t max_buf_index = -1;
-  shared = allocator_->CheckForBufferSharing(num_descriptors, descriptors, &max_buf_index);
-
-  if (test_allocate) {
-    status = shared ? GRALLOC1_ERROR_NOT_SHARED : status;
-    return status;
-  }
-
-  std::lock_guard<std::mutex> buffer_lock(buffer_lock_);
-  if (shared && (max_buf_index >= 0)) {
-    // Allocate one and duplicate/copy the handles for each descriptor
-    if (AllocateBufferLocked(*descriptors[UINT(max_buf_index)], &out_buffers[max_buf_index])) {
-      return GRALLOC1_ERROR_NO_RESOURCES;
-    }
-
-    for (i = 0; i < num_descriptors; i++) {
-      // Create new handle for a given descriptor.
-      // Current assumption is even MetaData memory would be same
-      // Need to revisit if there is a need for own metadata memory
-      if (i != UINT(max_buf_index)) {
-        CreateSharedHandle(out_buffers[max_buf_index], *descriptors[i], &out_buffers[i]);
-      }
-    }
-  } else {
-    // Buffer sharing is not feasible.
-    // Allocate separate buffer for each descriptor
-    for (i = 0; i < num_descriptors; i++) {
-      if (AllocateBufferLocked(*descriptors[i], &out_buffers[i])) {
-        return GRALLOC1_ERROR_NO_RESOURCES;
-      }
-    }
-  }
-
-  // Allocation is successful. If backstore is not shared inform the client.
-  if (!shared) {
-    return GRALLOC1_ERROR_NOT_SHARED;
-  }
-
-  return status;
-}
-
-void BufferManager::CreateSharedHandle(buffer_handle_t inbuffer, const BufferDescriptor &descriptor,
-                                       buffer_handle_t *outbuffer) {
-  // TODO(user): This path is not verified
-  private_handle_t const *input = reinterpret_cast<private_handle_t const *>(inbuffer);
-
-  // Get Buffer attributes or dimension
-  unsigned int alignedw = 0, alignedh = 0;
-  BufferInfo info = GetBufferInfo(descriptor);
-
-  GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
-
-  // create new handle from input reference handle and given descriptor
-  int flags = GetHandleFlags(descriptor.GetFormat(), descriptor.GetProducerUsage(),
-                             descriptor.GetConsumerUsage());
-  int buffer_type = GetBufferType(descriptor.GetFormat());
-
-  // Duplicate the fds
-  // TODO(user): Not sure what to do for fb_id. Use duped fd and new dimensions?
-  private_handle_t *out_hnd = new private_handle_t(dup(input->fd),
-                                                   dup(input->fd_metadata),
-                                                   flags,
-                                                   INT(alignedw),
-                                                   INT(alignedh),
-                                                   descriptor.GetWidth(),
-                                                   descriptor.GetHeight(),
-                                                   descriptor.GetFormat(),
-                                                   buffer_type,
-                                                   input->size,
-                                                   descriptor.GetProducerUsage(),
-                                                   descriptor.GetConsumerUsage());
-  out_hnd->id = ++next_id_;
-  // TODO(user): Base address of shared handle and ion handles
-  RegisterHandleLocked(out_hnd, -1, -1);
-  *outbuffer = out_hnd;
-}
-
-gralloc1_error_t BufferManager::FreeBuffer(std::shared_ptr<Buffer> buf) {
-  auto hnd = buf->handle;
-  ALOGD_IF(DEBUG, "FreeBuffer handle:%p", hnd);
-
-  if (private_handle_t::validate(hnd) != 0) {
-    ALOGE("FreeBuffer: Invalid handle: %p", hnd);
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
-                             hnd->fd, buf->ion_handle_main) != 0) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  unsigned int meta_size = ALIGN((unsigned int)sizeof(MetaData_t), PAGE_SIZE);
-  if (allocator_->FreeBuffer(reinterpret_cast<void *>(hnd->base_metadata), meta_size,
-                             hnd->offset_metadata, hnd->fd_metadata, buf->ion_handle_meta) != 0) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  private_handle_t * handle = const_cast<private_handle_t *>(hnd);
-  handle->fd = -1;
-  handle->fd_metadata = -1;
-  if (!(handle->flags & private_handle_t::PRIV_FLAGS_CLIENT_ALLOCATED)) {
-      delete handle;
-  }
-  return GRALLOC1_ERROR_NONE;
-}
-
-void BufferManager::RegisterHandleLocked(const private_handle_t *hnd,
-                                         int ion_handle,
-                                         int ion_handle_meta) {
-  auto buffer = std::make_shared<Buffer>(hnd, ion_handle, ion_handle_meta);
-  handles_map_.emplace(std::make_pair(hnd, buffer));
-}
-
-gralloc1_error_t BufferManager::ImportHandleLocked(private_handle_t *hnd) {
-  ALOGD_IF(DEBUG, "Importing handle:%p id: %" PRIu64, hnd, hnd->id);
-  int ion_handle = allocator_->ImportBuffer(hnd->fd);
-  if (ion_handle < 0) {
-    ALOGE("Failed to import ion buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd, hnd->fd, hnd->id);
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-  int ion_handle_meta = allocator_->ImportBuffer(hnd->fd_metadata);
-  if (ion_handle_meta < 0) {
-    ALOGE("Failed to import ion metadata buffer: hnd: %p, fd:%d, id:%" PRIu64, hnd,
-          hnd->fd, hnd->id);
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-  // Set base pointers to NULL since the data here was received over binder
-  hnd->base = 0;
-  hnd->base_metadata = 0;
-  RegisterHandleLocked(hnd, ion_handle, ion_handle_meta);
-  return GRALLOC1_ERROR_NONE;
-}
-
-std::shared_ptr<BufferManager::Buffer>
-BufferManager::GetBufferFromHandleLocked(const private_handle_t *hnd) {
-  auto it = handles_map_.find(hnd);
-  if (it != handles_map_.end()) {
-    return it->second;
-  } else {
-    return nullptr;
-  }
-}
-
-gralloc1_error_t BufferManager::MapBuffer(private_handle_t const *handle) {
-  private_handle_t *hnd = const_cast<private_handle_t *>(handle);
-  ALOGD_IF(DEBUG, "Map buffer handle:%p id: %" PRIu64, hnd, hnd->id);
-
-  hnd->base = 0;
-  if (allocator_->MapBuffer(reinterpret_cast<void **>(&hnd->base), hnd->size, hnd->offset,
-                            hnd->fd) != 0) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t BufferManager::RetainBuffer(private_handle_t const *hnd) {
-  ALOGD_IF(DEBUG, "Retain buffer handle:%p id: %" PRIu64, hnd, hnd->id);
-  gralloc1_error_t err = GRALLOC1_ERROR_NONE;
-  std::lock_guard<std::mutex> lock(buffer_lock_);
-  auto buf = GetBufferFromHandleLocked(hnd);
-  if (buf != nullptr) {
-    buf->IncRef();
-  } else {
-    private_handle_t *handle = const_cast<private_handle_t *>(hnd);
-    err = ImportHandleLocked(handle);
-  }
-  return err;
-}
-
-gralloc1_error_t BufferManager::ReleaseBuffer(private_handle_t const *hnd) {
-  ALOGD_IF(DEBUG, "Release buffer handle:%p", hnd);
-  std::lock_guard<std::mutex> lock(buffer_lock_);
-  auto buf = GetBufferFromHandleLocked(hnd);
-  if (buf == nullptr) {
-    ALOGE("Could not find handle: %p id: %" PRIu64, hnd, hnd->id);
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  } else {
-    if (buf->DecRef()) {
-      handles_map_.erase(hnd);
-      // Unmap, close ion handle and close fd
-      FreeBuffer(buf);
-    }
-  }
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t BufferManager::LockBuffer(const private_handle_t *hnd,
-                                           gralloc1_producer_usage_t prod_usage,
-                                           gralloc1_consumer_usage_t cons_usage) {
-  std::lock_guard<std::mutex> lock(buffer_lock_);
-  gralloc1_error_t err = GRALLOC1_ERROR_NONE;
-  ALOGD_IF(DEBUG, "LockBuffer buffer handle:%p id: %" PRIu64, hnd, hnd->id);
-
-  // If buffer is not meant for CPU return err
-  if (!CpuCanAccess(prod_usage, cons_usage)) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  auto buf = GetBufferFromHandleLocked(hnd);
-  if (buf == nullptr) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  if (hnd->base == 0) {
-    // we need to map for real
-    err = MapBuffer(hnd);
-  }
-
-  // Invalidate if CPU reads in software and there are non-CPU
-  // writers. No need to do this for the metadata buffer as it is
-  // only read/written in software.
-
-  // todo use handle here
-  if (!err && (hnd->flags & private_handle_t::PRIV_FLAGS_USES_ION) &&
-      (hnd->flags & private_handle_t::PRIV_FLAGS_CACHED)) {
-    if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
-                                buf->ion_handle_main, CACHE_INVALIDATE, hnd->fd)) {
-      return GRALLOC1_ERROR_BAD_HANDLE;
-    }
-  }
-
-  // Mark the buffer to be flushed after CPU write.
-  if (!err && CpuCanWrite(prod_usage)) {
-    private_handle_t *handle = const_cast<private_handle_t *>(hnd);
-    handle->flags |= private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
-  }
-
-  return err;
-}
-
-gralloc1_error_t BufferManager::UnlockBuffer(const private_handle_t *handle) {
-  std::lock_guard<std::mutex> lock(buffer_lock_);
-  gralloc1_error_t status = GRALLOC1_ERROR_NONE;
-
-  private_handle_t *hnd = const_cast<private_handle_t *>(handle);
-  auto buf = GetBufferFromHandleLocked(hnd);
-  if (buf == nullptr) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  if (hnd->flags & private_handle_t::PRIV_FLAGS_NEEDS_FLUSH) {
-    if (allocator_->CleanBuffer(reinterpret_cast<void *>(hnd->base), hnd->size, hnd->offset,
-                                buf->ion_handle_main, CACHE_CLEAN, hnd->fd) != 0) {
-      status = GRALLOC1_ERROR_BAD_HANDLE;
-    }
-    hnd->flags &= ~private_handle_t::PRIV_FLAGS_NEEDS_FLUSH;
-  }
-
-  return status;
-}
-
-uint32_t BufferManager::GetDataAlignment(int format, gralloc1_producer_usage_t prod_usage,
-                                    gralloc1_consumer_usage_t cons_usage) {
-  uint32_t align = UINT(getpagesize());
-  if (format == HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED) {
-    align = 8192;
-  }
-
-  if (prod_usage & GRALLOC1_PRODUCER_USAGE_PROTECTED) {
-    if ((prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) ||
-        (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY)) {
-      // The alignment here reflects qsee mmu V7L/V8L requirement
-      align = SZ_2M;
-    } else {
-      align = SECURE_ALIGN;
-    }
-  }
-
-  return align;
-}
-
-int BufferManager::GetHandleFlags(int format, gralloc1_producer_usage_t prod_usage,
-                                  gralloc1_consumer_usage_t cons_usage) {
-  int flags = 0;
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER) {
-    flags |= private_handle_t::PRIV_FLAGS_VIDEO_ENCODER;
-  }
-
-  if (prod_usage & GRALLOC1_PRODUCER_USAGE_CAMERA) {
-    flags |= private_handle_t::PRIV_FLAGS_CAMERA_WRITE;
-  }
-
-  if (prod_usage & GRALLOC1_CONSUMER_USAGE_CAMERA) {
-    flags |= private_handle_t::PRIV_FLAGS_CAMERA_READ;
-  }
-
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
-    flags |= private_handle_t::PRIV_FLAGS_HW_COMPOSER;
-  }
-
-  if (prod_usage & GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE) {
-    flags |= private_handle_t::PRIV_FLAGS_HW_TEXTURE;
-  }
-
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_PRIVATE_SECURE_DISPLAY) {
-    flags |= private_handle_t::PRIV_FLAGS_SECURE_DISPLAY;
-  }
-
-  if (IsUBwcEnabled(format, prod_usage, cons_usage)) {
-    flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-  }
-
-  if (prod_usage & (GRALLOC1_PRODUCER_USAGE_CPU_READ | GRALLOC1_PRODUCER_USAGE_CPU_WRITE)) {
-    flags |= private_handle_t::PRIV_FLAGS_CPU_RENDERED;
-  }
-
-  // TODO(user): is this correct???
-  if ((cons_usage &
-       (GRALLOC1_CONSUMER_USAGE_VIDEO_ENCODER | GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET)) ||
-      (prod_usage & (GRALLOC1_PRODUCER_USAGE_CAMERA | GRALLOC1_PRODUCER_USAGE_GPU_RENDER_TARGET))) {
-    flags |= private_handle_t::PRIV_FLAGS_NON_CPU_WRITER;
-  }
-
-  if (cons_usage & GRALLOC1_CONSUMER_USAGE_HWCOMPOSER) {
-    flags |= private_handle_t::PRIV_FLAGS_DISP_CONSUMER;
-  }
-
-  if (!allocator_->UseUncached(prod_usage, cons_usage)) {
-    flags |= private_handle_t::PRIV_FLAGS_CACHED;
-  }
-
-  return flags;
-}
-
-int BufferManager::GetBufferType(int inputFormat) {
-  int buffer_type = BUFFER_TYPE_VIDEO;
-  if (IsUncompressedRGBFormat(inputFormat)) {
-    // RGB formats
-    buffer_type = BUFFER_TYPE_UI;
-  }
-
-  return buffer_type;
-}
-
-int BufferManager::AllocateBufferLocked(const BufferDescriptor &descriptor, buffer_handle_t *handle,
-                                        unsigned int bufferSize) {
-  if (!handle)
-    return -EINVAL;
-
-  gralloc1_producer_usage_t prod_usage = descriptor.GetProducerUsage();
-  gralloc1_consumer_usage_t cons_usage = descriptor.GetConsumerUsage();
-  int format = allocator_->GetImplDefinedFormat(prod_usage, cons_usage, descriptor.GetFormat());
-  uint32_t layer_count = descriptor.GetLayerCount();
-
-  unsigned int size;
-  unsigned int alignedw, alignedh;
-
-  int buffer_type = GetBufferType(format);
-  BufferInfo info = GetBufferInfo(descriptor);
-  GetBufferSizeAndDimensions(info, &size, &alignedw, &alignedh);
-  size = (bufferSize >= size) ? bufferSize : size;
-
-  int err = 0;
-  int flags = 0;
-  auto page_size = UINT(getpagesize());
-  AllocData data;
-  data.align = GetDataAlignment(format, prod_usage, cons_usage);
-  size = ALIGN(size, data.align) * layer_count;
-  data.size = size;
-  data.handle = (uintptr_t) handle;
-  data.uncached = allocator_->UseUncached(prod_usage, cons_usage);
-
-  // Allocate buffer memory
-  err = allocator_->AllocateMem(&data, prod_usage, cons_usage);
-  if (err) {
-    ALOGE("gralloc failed to allocate err=%s", strerror(-err));
-    return err;
-  }
-
-  // Allocate memory for MetaData
-  AllocData e_data;
-  e_data.size = ALIGN(UINT(sizeof(MetaData_t)), page_size);
-  e_data.handle = data.handle;
-  e_data.align = page_size;
-
-  err =
-      allocator_->AllocateMem(&e_data, GRALLOC1_PRODUCER_USAGE_NONE, GRALLOC1_CONSUMER_USAGE_NONE);
-  if (err) {
-    ALOGE("gralloc failed to allocate metadata error=%s", strerror(-err));
-    return err;
-  }
-
-  flags = GetHandleFlags(format, prod_usage, cons_usage);
-  flags |= data.alloc_type;
-
-  // Create handle
-  private_handle_t *hnd = new private_handle_t(data.fd,
-                                               e_data.fd,
-                                               flags,
-                                               INT(alignedw),
-                                               INT(alignedh),
-                                               descriptor.GetWidth(),
-                                               descriptor.GetHeight(),
-                                               format,
-                                               buffer_type,
-                                               data.size,
-                                               prod_usage,
-                                               cons_usage);
-
-  hnd->id = ++next_id_;
-  hnd->base = 0;
-  hnd->base_metadata = 0;
-  hnd->layer_count = layer_count;
-
-  if (buffer_type == BUFFER_TYPE_VIDEO) {
-    // set default csc to 601L for only video buffers
-    ColorSpace_t colorSpace = ITU_R_601;
-    setMetaData(hnd, UPDATE_COLOR_SPACE, reinterpret_cast<void *>(&colorSpace));
-  }
-  *handle = hnd;
-  RegisterHandleLocked(hnd, data.ion_handle, e_data.ion_handle);
-  ALOGD_IF(DEBUG, "Allocated buffer handle: %p id: %" PRIu64, hnd, hnd->id);
-  if (DEBUG) {
-    private_handle_t::Dump(hnd);
-  }
-  return err;
-}
-
-gralloc1_error_t BufferManager::Perform(int operation, va_list args) {
-  switch (operation) {
-    case GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER: {
-      int fd = va_arg(args, int);
-      unsigned int size = va_arg(args, unsigned int);
-      unsigned int offset = va_arg(args, unsigned int);
-      void *base = va_arg(args, void *);
-      int width = va_arg(args, int);
-      int height = va_arg(args, int);
-      int format = va_arg(args, int);
-
-      native_handle_t **handle = va_arg(args, native_handle_t **);
-      if (!handle) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      private_handle_t *hnd = reinterpret_cast<private_handle_t *>(
-          native_handle_create(private_handle_t::kNumFds, private_handle_t::NumInts()));
-      if (hnd) {
-        unsigned int alignedw = 0, alignedh = 0;
-        hnd->magic = private_handle_t::kMagic;
-        hnd->fd = fd;
-        hnd->flags = private_handle_t::PRIV_FLAGS_USES_ION;
-        hnd->size = size;
-        hnd->offset = offset;
-        hnd->base = uint64_t(base);
-        hnd->gpuaddr = 0;
-        BufferInfo info(width, height, format);
-        GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
-        hnd->unaligned_width = width;
-        hnd->unaligned_height = height;
-        hnd->width = INT(alignedw);
-        hnd->height = INT(alignedh);
-        hnd->format = format;
-        *handle = reinterpret_cast<native_handle_t *>(hnd);
-      }
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_STRIDE: {
-      int width = va_arg(args, int);
-      int format = va_arg(args, int);
-      int *stride = va_arg(args, int *);
-      unsigned int alignedw = 0, alignedh = 0;
-
-      if (!stride) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      BufferInfo info(width, width, format);
-      GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
-      *stride = INT(alignedw);
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_FROM_HANDLE: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      int *stride = va_arg(args, int *);
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!stride) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      BufferDim_t buffer_dim;
-      if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
-        *stride = buffer_dim.sliceWidth;
-      } else {
-        *stride = hnd->width;
-      }
-    } break;
-
-    // TODO(user) : this alone should be sufficient, ask gfx to get rid of above
-    case GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      int *stride = va_arg(args, int *);
-      int *height = va_arg(args, int *);
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!stride || !height) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      BufferDim_t buffer_dim;
-      int interlaced = 0;
-
-      *stride = hnd->width;
-      *height = hnd->height;
-      if (getMetaData(hnd, GET_BUFFER_GEOMETRY, &buffer_dim) == 0) {
-        *stride = buffer_dim.sliceWidth;
-        *height = buffer_dim.sliceHeight;
-      } else if (getMetaData(hnd, GET_PP_PARAM_INTERLACED, &interlaced) == 0) {
-        if (interlaced && IsUBwcFormat(hnd->format)) {
-          unsigned int alignedw = 0, alignedh = 0;
-          // Get re-aligned height for single ubwc interlaced field and
-          // multiple by 2 to get frame height.
-          BufferInfo info(hnd->width, ((hnd->height+1)>>1), hnd->format);
-          GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
-          *stride = static_cast<int>(alignedw);
-          *height = static_cast<int>(alignedh * 2);
-        }
-      }
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES: {
-      // TODO(user): Usage is split now. take care of it from Gfx client.
-      // see if we can directly expect descriptor from gfx client.
-      int width = va_arg(args, int);
-      int height = va_arg(args, int);
-      int format = va_arg(args, int);
-      uint64_t producer_usage = va_arg(args, uint64_t);
-      uint64_t consumer_usage = va_arg(args, uint64_t);
-      gralloc1_producer_usage_t prod_usage = static_cast<gralloc1_producer_usage_t>(producer_usage);
-      gralloc1_consumer_usage_t cons_usage = static_cast<gralloc1_consumer_usage_t>(consumer_usage);
-
-      int *aligned_width = va_arg(args, int *);
-      int *aligned_height = va_arg(args, int *);
-      int *tile_enabled = va_arg(args, int *);
-      if (!aligned_width || !aligned_height || !tile_enabled) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      unsigned int alignedw, alignedh;
-      BufferInfo info(width, height, format, prod_usage, cons_usage);
-      *tile_enabled = IsUBwcEnabled(format, prod_usage, cons_usage);
-      GetAlignedWidthAndHeight(info, &alignedw, &alignedh);
-      *aligned_width = INT(alignedw);
-      *aligned_height = INT(alignedh);
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_COLOR_SPACE_FROM_HANDLE: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      int *color_space = va_arg(args, int *);
-
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!color_space) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      *color_space = 0;
-#ifdef USE_COLOR_METADATA
-      ColorMetaData color_metadata;
-      if (getMetaData(hnd, GET_COLOR_METADATA, &color_metadata) == 0) {
-        switch (color_metadata.colorPrimaries) {
-          case ColorPrimaries_BT709_5:
-            *color_space = HAL_CSC_ITU_R_709;
-            break;
-          case ColorPrimaries_BT601_6_525:
-          case ColorPrimaries_BT601_6_625:
-            *color_space = ((color_metadata.range) ? HAL_CSC_ITU_R_601_FR : HAL_CSC_ITU_R_601);
-            break;
-          case ColorPrimaries_BT2020:
-            *color_space = (color_metadata.range) ? HAL_CSC_ITU_R_2020_FR : HAL_CSC_ITU_R_2020;
-            break;
-          default:
-            ALOGE("Unknown Color Space = %d", color_metadata.colorPrimaries);
-            break;
-        }
-        break;
-      } else if (getMetaData(hnd, GET_COLOR_SPACE, color_space) != 0) {
-          *color_space = 0;
-      }
-#else
-      if (getMetaData(hnd, GET_COLOR_SPACE, color_space) != 0) {
-          *color_space = 0;
-      }
-#endif
-    } break;
-    case GRALLOC_MODULE_PERFORM_GET_YUV_PLANE_INFO: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      android_ycbcr *ycbcr = va_arg(args, struct android_ycbcr *);
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!ycbcr) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      if (GetYUVPlaneInfo(hnd, ycbcr)) {
-        return GRALLOC1_ERROR_UNDEFINED;
-      }
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_MAP_SECURE_BUFFER_INFO: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      int *map_secure_buffer = va_arg(args, int *);
-
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!map_secure_buffer) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      if (getMetaData(hnd, GET_MAP_SECURE_BUFFER, map_secure_buffer) != 0) {
-        *map_secure_buffer = 0;
-      }
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_UBWC_FLAG: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      int *flag = va_arg(args, int *);
-
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!flag) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      *flag = hnd->flags &private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
-      int linear_format = 0;
-      if (getMetaData(hnd, GET_LINEAR_FORMAT, &linear_format) == 0) {
-        if (linear_format) {
-         *flag = 0;
-        }
-      }
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_GET_RGB_DATA_ADDRESS: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      void **rgb_data = va_arg(args, void **);
-
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!rgb_data) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      if (GetRgbDataAddress(hnd, rgb_data)) {
-        return GRALLOC1_ERROR_UNDEFINED;
-      }
-    } break;
-
-    case GRALLOC1_MODULE_PERFORM_GET_BUFFER_SIZE_AND_DIMENSIONS: {
-      int width = va_arg(args, int);
-      int height = va_arg(args, int);
-      int format = va_arg(args, int);
-      uint64_t p_usage = va_arg(args, uint64_t);
-      uint64_t c_usage = va_arg(args, uint64_t);
-      gralloc1_producer_usage_t producer_usage = static_cast<gralloc1_producer_usage_t>(p_usage);
-      gralloc1_consumer_usage_t consumer_usage = static_cast<gralloc1_consumer_usage_t>(c_usage);
-      uint32_t *aligned_width = va_arg(args, uint32_t *);
-      uint32_t *aligned_height = va_arg(args, uint32_t *);
-      uint32_t *size = va_arg(args, uint32_t *);
-
-      if (!aligned_width || !aligned_height || !size) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      auto info = BufferInfo(width, height, format, producer_usage, consumer_usage);
-      GetBufferSizeAndDimensions(info, size, aligned_width, aligned_height);
-      // Align size
-      auto align = GetDataAlignment(format, producer_usage, consumer_usage);
-      *size = ALIGN(*size, align);
-    } break;
-
-    case GRALLOC1_MODULE_PERFORM_GET_INTERLACE_FLAG: {
-      private_handle_t *hnd = va_arg(args, private_handle_t *);
-      int *flag = va_arg(args, int *);
-
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-
-      if (!flag) {
-        return GRALLOC1_ERROR_BAD_VALUE;
-      }
-
-      if (getMetaData(hnd, GET_PP_PARAM_INTERLACED, flag) != 0) {
-        *flag = 0;
-      }
-    } break;
-
-    case GRALLOC_MODULE_PERFORM_SET_SINGLE_BUFFER_MODE: {
-      private_handle_t* hnd =  va_arg(args, private_handle_t*);
-      uint32_t *enable = va_arg(args, uint32_t*);
-      if (private_handle_t::validate(hnd) != 0) {
-        return GRALLOC1_ERROR_BAD_HANDLE;
-      }
-      if (setMetaData(hnd, SET_SINGLE_BUFFER_MODE, enable) != 0) {
-        return GRALLOC1_ERROR_UNSUPPORTED;
-      }
-    } break;
-
-    default:
-      break;
-  }
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t BufferManager::GetNumFlexPlanes(const private_handle_t *hnd,
-                                                 uint32_t *out_num_planes) {
-  if (!IsYuvFormat(hnd)) {
-    return GRALLOC1_ERROR_UNSUPPORTED;
-  } else {
-    *out_num_planes = 3;
-  }
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t BufferManager::GetFlexLayout(const private_handle_t *hnd,
-                                              struct android_flex_layout *layout) {
-  if (!IsYuvFormat(hnd)) {
-    return GRALLOC1_ERROR_UNSUPPORTED;
-  }
-
-  android_ycbcr yuvPlaneInfo[2];
-  int err = GetYUVPlaneInfo(hnd, yuvPlaneInfo);
-
-  if (err != 0) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  layout->format = FLEX_FORMAT_YCbCr;
-  layout->num_planes = 3;
-
-  for (uint32_t i = 0; i < layout->num_planes; i++) {
-    layout->planes[i].bits_per_component = 8;
-    layout->planes[i].bits_used = 8;
-    layout->planes[i].h_increment = 1;
-    layout->planes[i].v_increment = 1;
-    layout->planes[i].h_subsampling = 2;
-    layout->planes[i].v_subsampling = 2;
-  }
-
-  // We are only returning flex layout for progressive or single field formats.
-  struct android_ycbcr ycbcr = yuvPlaneInfo[0];
-  layout->planes[0].top_left = static_cast<uint8_t *>(ycbcr.y);
-  layout->planes[0].component = FLEX_COMPONENT_Y;
-  layout->planes[0].v_increment = static_cast<int32_t>(ycbcr.ystride);
-
-  layout->planes[1].top_left = static_cast<uint8_t *>(ycbcr.cb);
-  layout->planes[1].component = FLEX_COMPONENT_Cb;
-  layout->planes[1].h_increment = static_cast<int32_t>(ycbcr.chroma_step);
-  layout->planes[1].v_increment = static_cast<int32_t>(ycbcr.cstride);
-
-  layout->planes[2].top_left = static_cast<uint8_t *>(ycbcr.cr);
-  layout->planes[2].component = FLEX_COMPONENT_Cr;
-  layout->planes[2].h_increment = static_cast<int32_t>(ycbcr.chroma_step);
-  layout->planes[2].v_increment = static_cast<int32_t>(ycbcr.cstride);
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t BufferManager::Dump(std::ostringstream *os) {
-  for (auto it : handles_map_) {
-    auto buf = it.second;
-    auto hnd = buf->handle;
-    *os << "handle id: " << std::setw(4) << hnd->id;
-    *os << " fd: "       << std::setw(3) << hnd->fd;
-    *os << " fd_meta: "  << std::setw(3) << hnd->fd_metadata;
-    *os << " wxh: "      << std::setw(4) << hnd->width <<" x " << std::setw(4) <<  hnd->height;
-    *os << " uwxuh: "    << std::setw(4) << hnd->unaligned_width << " x ";
-    *os << std::setw(4)  <<  hnd->unaligned_height;
-    *os << " size: "     << std::setw(9) << hnd->size;
-    *os << std::hex << std::setfill('0');
-    *os << " priv_flags: " << "0x" << std::setw(8) << hnd->flags;
-    *os << " prod_usage: " << "0x" << std::setw(8) << hnd->producer_usage;
-    *os << " cons_usage: " << "0x" << std::setw(8) << hnd->consumer_usage;
-    // TODO(user): get format string from qdutils
-    *os << " format: "     << "0x" << std::setw(8) << hnd->format;
-    *os << std::dec  << std::setfill(' ') << std::endl;
-  }
-  return GRALLOC1_ERROR_NONE;
-}
-}  //  namespace gralloc1
diff --git a/libgralloc1/gr_buf_mgr.h b/libgralloc1/gr_buf_mgr.h
deleted file mode 100644
index e021afd..0000000
--- a/libgralloc1/gr_buf_mgr.h
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.
- * Not a Contribution
- *
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __GR_BUF_MGR_H__
-#define __GR_BUF_MGR_H__
-
-#include <pthread.h>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <mutex>
-
-#include "gralloc_priv.h"
-#include "gr_allocator.h"
-#include "gr_buf_descriptor.h"
-
-namespace gralloc1 {
-
-class BufferManager {
- public:
-  ~BufferManager();
-  gralloc1_error_t CreateBufferDescriptor(gralloc1_buffer_descriptor_t *descriptor_id);
-  gralloc1_error_t DestroyBufferDescriptor(gralloc1_buffer_descriptor_t descriptor_id);
-  gralloc1_error_t AllocateBuffers(uint32_t num_descriptors,
-                                   const gralloc1_buffer_descriptor_t *descriptor_ids,
-                                   buffer_handle_t *out_buffers);
-  gralloc1_error_t RetainBuffer(private_handle_t const *hnd);
-  gralloc1_error_t ReleaseBuffer(private_handle_t const *hnd);
-  gralloc1_error_t LockBuffer(const private_handle_t *hnd, gralloc1_producer_usage_t prod_usage,
-                              gralloc1_consumer_usage_t cons_usage);
-  gralloc1_error_t UnlockBuffer(const private_handle_t *hnd);
-  gralloc1_error_t Perform(int operation, va_list args);
-  gralloc1_error_t GetFlexLayout(const private_handle_t *hnd, struct android_flex_layout *layout);
-  gralloc1_error_t GetNumFlexPlanes(const private_handle_t *hnd, uint32_t *out_num_planes);
-  gralloc1_error_t Dump(std::ostringstream *os);
-
-  template <typename... Args>
-  gralloc1_error_t CallBufferDescriptorFunction(gralloc1_buffer_descriptor_t descriptor_id,
-                                                void (BufferDescriptor::*member)(Args...),
-                                                Args... args) {
-    std::lock_guard<std::mutex> lock(descriptor_lock_);
-    const auto map_descriptor = descriptors_map_.find(descriptor_id);
-    if (map_descriptor == descriptors_map_.end()) {
-      return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-    }
-    const auto descriptor = map_descriptor->second;
-    (descriptor.get()->*member)(std::forward<Args>(args)...);
-    return GRALLOC1_ERROR_NONE;
-  }
-
-  static BufferManager* GetInstance() {
-    static BufferManager *instance = new BufferManager();
-    return instance;
-  }
-
- private:
-  BufferManager();
-  gralloc1_error_t MapBuffer(private_handle_t const *hnd);
-  int GetBufferType(int format);
-  int AllocateBufferLocked(const BufferDescriptor &descriptor, buffer_handle_t *handle,
-                           unsigned int bufferSize = 0);
-  uint32_t GetDataAlignment(int format, gralloc1_producer_usage_t prod_usage,
-                       gralloc1_consumer_usage_t cons_usage);
-  int GetHandleFlags(int format, gralloc1_producer_usage_t prod_usage,
-                     gralloc1_consumer_usage_t cons_usage);
-  void CreateSharedHandle(buffer_handle_t inbuffer, const BufferDescriptor &descriptor,
-                          buffer_handle_t *out_buffer);
-
-  // Imports the ion fds into the current process. Returns an error for invalid handles
-  gralloc1_error_t ImportHandleLocked(private_handle_t *hnd);
-
-  // Creates a Buffer from the valid private handle and adds it to the map
-  void RegisterHandleLocked(const private_handle_t *hnd, int ion_handle, int ion_handle_meta);
-
-  // Wrapper structure over private handle
-  // Values associated with the private handle
-  // that do not need to go over IPC can be placed here
-  // This structure is also not expected to be ABI stable
-  // unlike private_handle_t
-  struct Buffer {
-    const private_handle_t *handle = nullptr;
-    int ref_count = 1;
-    // Hold the main and metadata ion handles
-    // Freed from the allocator process
-    // and unused in the mapping process
-    int ion_handle_main = -1;
-    int ion_handle_meta = -1;
-
-    Buffer() = delete;
-    explicit Buffer(const private_handle_t* h, int ih_main = -1, int ih_meta = -1):
-        handle(h),
-        ion_handle_main(ih_main),
-        ion_handle_meta(ih_meta) {
-    }
-    void IncRef() { ++ref_count; }
-    bool DecRef() { return --ref_count == 0; }
-  };
-
-  gralloc1_error_t FreeBuffer(std::shared_ptr<Buffer> buf);
-
-  // Get the wrapper Buffer object from the handle, returns nullptr if handle is not found
-  std::shared_ptr<Buffer> GetBufferFromHandleLocked(const private_handle_t *hnd);
-
-  bool map_fb_mem_ = false;
-  Allocator *allocator_ = NULL;
-  std::mutex buffer_lock_;
-  std::mutex descriptor_lock_;
-  // TODO(user): The private_handle_t is used as a key because the unique ID generated
-  // from next_id_ is not unique across processes. The correct way to resolve this would
-  // be to use the allocator over hwbinder
-  std::unordered_map<const private_handle_t*, std::shared_ptr<Buffer>> handles_map_ = {};
-  std::unordered_map<gralloc1_buffer_descriptor_t,
-                     std::shared_ptr<BufferDescriptor>> descriptors_map_ = {};
-  std::atomic<uint64_t> next_id_;
-};
-
-}  // namespace gralloc1
-
-#endif  // __GR_BUF_MGR_H__
diff --git a/libgralloc1/gr_device_impl.cpp b/libgralloc1/gr_device_impl.cpp
deleted file mode 100644
index c900d23..0000000
--- a/libgralloc1/gr_device_impl.cpp
+++ /dev/null
@@ -1,536 +0,0 @@
-/*
- * Copyright (c) 2016-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
- * met:
- *   * Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above
- *     copyright notice, this list of conditions and the following
- *     disclaimer in the documentation and/or other materials provided
- *     with the distribution.
- *   * Neither the name of The Linux Foundation nor the names of its
- *     contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
- * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
- * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
- * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#define ATRACE_TAG (ATRACE_TAG_GRAPHICS | ATRACE_TAG_HAL)
-#include <cutils/log.h>
-#include <utils/Trace.h>
-#include <cutils/trace.h>
-#include <sync/sync.h>
-#include <algorithm>
-#include <sstream>
-#include <string>
-
-#include "gr_device_impl.h"
-#include "gr_buf_descriptor.h"
-#include "gralloc_priv.h"
-#include "qd_utils.h"
-#include "qdMetaData.h"
-#include "gr_utils.h"
-
-int gralloc_device_open(const struct hw_module_t *module, const char *name, hw_device_t **device);
-
-int gralloc_device_close(struct hw_device_t *device);
-
-static struct hw_module_methods_t gralloc_module_methods = {.open = gralloc_device_open};
-
-struct gralloc_module_t HAL_MODULE_INFO_SYM = {
-  .common = {
-    .tag = HARDWARE_MODULE_TAG,
-    .module_api_version = GRALLOC_MODULE_API_VERSION_1_0,
-    .hal_api_version    = HARDWARE_HAL_API_VERSION,
-    .id = GRALLOC_HARDWARE_MODULE_ID,
-    .name = "Graphics Memory Module",
-    .author = "Code Aurora Forum",
-    .methods = &gralloc_module_methods,
-    .dso = 0,
-    .reserved = {0},
-  },
-};
-
-int gralloc_device_open(const struct hw_module_t *module, const char *name, hw_device_t **device) {
-  int status = -EINVAL;
-  if (module && device && !strcmp(name, GRALLOC_HARDWARE_MODULE_ID)) {
-    gralloc1::GrallocImpl * /*gralloc1_device_t*/ dev = gralloc1::GrallocImpl::GetInstance(module);
-    *device = reinterpret_cast<hw_device_t *>(dev);
-    if (dev) {
-      status = 0;
-    } else {
-      ALOGE("Fatal error opening gralloc1 device");
-    }
-  }
-  return status;
-}
-
-namespace gralloc1 {
-
-GrallocImpl::GrallocImpl(const hw_module_t *module) {
-  common.tag = HARDWARE_DEVICE_TAG;
-  common.version = GRALLOC_MODULE_API_VERSION_1_0;
-  common.module = const_cast<hw_module_t *>(module);
-  common.close = CloseDevice;
-  getFunction = GetFunction;
-  getCapabilities = GetCapabilities;
-
-  initalized_ = Init();
-}
-
-bool GrallocImpl::Init() {
-  buf_mgr_ = BufferManager::GetInstance();
-  return buf_mgr_ != nullptr;
-}
-
-GrallocImpl::~GrallocImpl() {
-}
-
-int GrallocImpl::CloseDevice(hw_device_t *device __unused) {
-  // No-op since the gralloc device is a singleton
-  return 0;
-}
-
-void GrallocImpl::GetCapabilities(struct gralloc1_device *device, uint32_t *out_count,
-                                  int32_t  /*gralloc1_capability_t*/ *out_capabilities) {
-  if (device != nullptr && out_count != nullptr) {
-    if (out_capabilities != nullptr && *out_count >= 3) {
-      out_capabilities[0] = GRALLOC1_CAPABILITY_TEST_ALLOCATE;
-      out_capabilities[1] = GRALLOC1_CAPABILITY_LAYERED_BUFFERS;
-      out_capabilities[2] = GRALLOC1_CAPABILITY_RELEASE_IMPLY_DELETE;
-    }
-    *out_count = 3;
-  }
-  return;
-}
-
-gralloc1_function_pointer_t GrallocImpl::GetFunction(gralloc1_device_t *device, int32_t function) {
-  if (!device) {
-    return NULL;
-  }
-
-  switch (function) {
-    case GRALLOC1_FUNCTION_DUMP:
-      return reinterpret_cast<gralloc1_function_pointer_t>(Dump);
-    case GRALLOC1_FUNCTION_CREATE_DESCRIPTOR:
-      return reinterpret_cast<gralloc1_function_pointer_t>(CreateBufferDescriptor);
-    case GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR:
-      return reinterpret_cast<gralloc1_function_pointer_t>(DestroyBufferDescriptor);
-    case GRALLOC1_FUNCTION_SET_CONSUMER_USAGE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(SetConsumerUsage);
-    case GRALLOC1_FUNCTION_SET_DIMENSIONS:
-      return reinterpret_cast<gralloc1_function_pointer_t>(SetBufferDimensions);
-    case GRALLOC1_FUNCTION_SET_FORMAT:
-      return reinterpret_cast<gralloc1_function_pointer_t>(SetColorFormat);
-    case GRALLOC1_FUNCTION_SET_LAYER_COUNT:
-      return reinterpret_cast<gralloc1_function_pointer_t>(SetLayerCount);
-    case GRALLOC1_FUNCTION_SET_PRODUCER_USAGE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(SetProducerUsage);
-    case GRALLOC1_FUNCTION_GET_BACKING_STORE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetBackingStore);
-    case GRALLOC1_FUNCTION_GET_CONSUMER_USAGE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetConsumerUsage);
-    case GRALLOC1_FUNCTION_GET_DIMENSIONS:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetBufferDimensions);
-    case GRALLOC1_FUNCTION_GET_FORMAT:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetColorFormat);
-    case GRALLOC1_FUNCTION_GET_LAYER_COUNT:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetLayerCount);
-    case GRALLOC1_FUNCTION_GET_PRODUCER_USAGE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetProducerUsage);
-    case GRALLOC1_FUNCTION_GET_STRIDE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetBufferStride);
-    case GRALLOC1_FUNCTION_ALLOCATE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(AllocateBuffers);
-    case GRALLOC1_FUNCTION_RETAIN:
-      return reinterpret_cast<gralloc1_function_pointer_t>(RetainBuffer);
-    case GRALLOC1_FUNCTION_RELEASE:
-      return reinterpret_cast<gralloc1_function_pointer_t>(ReleaseBuffer);
-    case GRALLOC1_FUNCTION_GET_NUM_FLEX_PLANES:
-      return reinterpret_cast<gralloc1_function_pointer_t>(GetNumFlexPlanes);
-    case GRALLOC1_FUNCTION_LOCK:
-      return reinterpret_cast<gralloc1_function_pointer_t>(LockBuffer);
-    case GRALLOC1_FUNCTION_LOCK_FLEX:
-      return reinterpret_cast<gralloc1_function_pointer_t>(LockFlex);
-    case GRALLOC1_FUNCTION_UNLOCK:
-      return reinterpret_cast<gralloc1_function_pointer_t>(UnlockBuffer);
-    case GRALLOC1_FUNCTION_PERFORM:
-      return reinterpret_cast<gralloc1_function_pointer_t>(Gralloc1Perform);
-    default:
-      ALOGE("%s:Gralloc Error. Client Requested for unsupported function", __FUNCTION__);
-      return NULL;
-  }
-
-  return NULL;
-}
-
-gralloc1_error_t GrallocImpl::Dump(gralloc1_device_t *device, uint32_t *out_size,
-                                   char *out_buffer) {
-  if (!device || !out_size) {
-    ALOGE("Gralloc Error : device=%p", (void *)device);
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  }
-  const size_t max_dump_size = 8192;
-  if (out_buffer == nullptr) {
-    *out_size = max_dump_size;
-  } else {
-    std::ostringstream os;
-    os << "-------------------------------" << std::endl;
-    os << "QTI gralloc dump:" << std::endl;
-    os << "-------------------------------" << std::endl;
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    dev->buf_mgr_->Dump(&os);
-    os << "-------------------------------" << std::endl;
-    auto copied = os.str().copy(out_buffer, std::min(os.str().size(), max_dump_size), 0);
-    *out_size = UINT(copied);
-  }
-
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t GrallocImpl::CheckDeviceAndHandle(gralloc1_device_t *device,
-                                                   buffer_handle_t buffer) {
-  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-  if (!device || (private_handle_t::validate(hnd) != 0)) {
-    ALOGE("Gralloc Error : device= %p, buffer-handle=%p", (void *)device, (void *)buffer);
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t GrallocImpl::CreateBufferDescriptor(gralloc1_device_t *device,
-                                                     gralloc1_buffer_descriptor_t *out_descriptor) {
-  if (!device || !out_descriptor) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  }
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-  return dev->buf_mgr_->CreateBufferDescriptor(out_descriptor);
-}
-
-gralloc1_error_t GrallocImpl::DestroyBufferDescriptor(gralloc1_device_t *device,
-                                                      gralloc1_buffer_descriptor_t descriptor) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  }
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-  return dev->buf_mgr_->DestroyBufferDescriptor(descriptor);
-}
-
-gralloc1_error_t GrallocImpl::SetConsumerUsage(gralloc1_device_t *device,
-                                               gralloc1_buffer_descriptor_t descriptor,
-                                               gralloc1_consumer_usage_t usage) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  } else {
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    return dev->buf_mgr_->CallBufferDescriptorFunction(descriptor,
-                                                       &BufferDescriptor::SetConsumerUsage, usage);
-  }
-}
-
-gralloc1_error_t GrallocImpl::SetBufferDimensions(gralloc1_device_t *device,
-                                                  gralloc1_buffer_descriptor_t descriptor,
-                                                  uint32_t width, uint32_t height) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  } else {
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    return dev->buf_mgr_->CallBufferDescriptorFunction(descriptor,
-                                                       &BufferDescriptor::SetDimensions,
-                                                       INT(width), INT(height));
-  }
-}
-
-gralloc1_error_t GrallocImpl::SetColorFormat(gralloc1_device_t *device,
-                                             gralloc1_buffer_descriptor_t descriptor,
-                                             int32_t format) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  } else {
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    return dev->buf_mgr_->CallBufferDescriptorFunction(descriptor,
-                                                       &BufferDescriptor::SetColorFormat, format);
-  }
-}
-
-gralloc1_error_t GrallocImpl::SetLayerCount(gralloc1_device_t *device,
-                                            gralloc1_buffer_descriptor_t descriptor,
-                                            uint32_t layer_count) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  } else {
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    return dev->buf_mgr_->CallBufferDescriptorFunction(descriptor,
-                                                       &BufferDescriptor::SetLayerCount,
-                                                       layer_count);
-  }
-}
-
-gralloc1_error_t GrallocImpl::SetProducerUsage(gralloc1_device_t *device,
-                                               gralloc1_buffer_descriptor_t descriptor,
-                                               gralloc1_producer_usage_t usage) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  } else {
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    return dev->buf_mgr_->CallBufferDescriptorFunction(descriptor,
-                                                       &BufferDescriptor::SetProducerUsage, usage);
-  }
-}
-
-gralloc1_error_t GrallocImpl::GetBackingStore(gralloc1_device_t *device, buffer_handle_t buffer,
-                                              gralloc1_backing_store_t *out_backstore) {
-  if (!device || !buffer) {
-    return GRALLOC1_ERROR_BAD_HANDLE;
-  }
-
-  *out_backstore =
-      static_cast<gralloc1_backing_store_t>(PRIV_HANDLE_CONST(buffer)->GetBackingstore());
-
-  return GRALLOC1_ERROR_NONE;
-}
-
-gralloc1_error_t GrallocImpl::GetConsumerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
-                                               gralloc1_consumer_usage_t *outUsage) {
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    *outUsage = PRIV_HANDLE_CONST(buffer)->GetConsumerUsage();
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::GetBufferDimensions(gralloc1_device_t *device, buffer_handle_t buffer,
-                                                  uint32_t *outWidth, uint32_t *outHeight) {
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-    *outWidth = UINT(hnd->GetUnalignedWidth());
-    *outHeight = UINT(hnd->GetUnalignedHeight());
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::GetColorFormat(gralloc1_device_t *device, buffer_handle_t buffer,
-                                             int32_t *outFormat) {
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    *outFormat = PRIV_HANDLE_CONST(buffer)->GetColorFormat();
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::GetLayerCount(gralloc1_device_t *device, buffer_handle_t buffer,
-                                            uint32_t *outLayerCount) {
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    *outLayerCount = PRIV_HANDLE_CONST(buffer)->GetLayerCount();
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::GetProducerUsage(gralloc1_device_t *device, buffer_handle_t buffer,
-                                               gralloc1_producer_usage_t *outUsage) {
-  if (!outUsage) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-    *outUsage = hnd->GetProducerUsage();
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::GetBufferStride(gralloc1_device_t *device, buffer_handle_t buffer,
-                                              uint32_t *outStride) {
-  if (!outStride) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    *outStride = UINT(PRIV_HANDLE_CONST(buffer)->GetStride());
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::AllocateBuffers(gralloc1_device_t *device, uint32_t num_descriptors,
-                                              const gralloc1_buffer_descriptor_t *descriptors,
-                                              buffer_handle_t *out_buffers) {
-  if (!num_descriptors || !descriptors) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  }
-
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-  gralloc1_error_t status = dev->buf_mgr_->AllocateBuffers(num_descriptors, descriptors,
-                                                           out_buffers);
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::RetainBuffer(gralloc1_device_t *device, buffer_handle_t buffer) {
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    status = dev->buf_mgr_->RetainBuffer(hnd);
-  }
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::ReleaseBuffer(gralloc1_device_t *device, buffer_handle_t buffer) {
-  if (!device || !buffer) {
-    return GRALLOC1_ERROR_BAD_DESCRIPTOR;
-  }
-
-  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-  return dev->buf_mgr_->ReleaseBuffer(hnd);
-}
-
-gralloc1_error_t GrallocImpl::GetNumFlexPlanes(gralloc1_device_t *device, buffer_handle_t buffer,
-                                               uint32_t *out_num_planes) {
-  if (!out_num_planes) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status == GRALLOC1_ERROR_NONE) {
-    GrallocImpl const *dev = GRALLOC_IMPL(device);
-    const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-    status = dev->buf_mgr_->GetNumFlexPlanes(hnd, out_num_planes);
-  }
-  return status;
-}
-
-static inline void CloseFdIfValid(int fd) {
-  if (fd > 0) {
-    close(fd);
-  }
-}
-
-gralloc1_error_t GrallocImpl::LockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
-                                         gralloc1_producer_usage_t prod_usage,
-                                         gralloc1_consumer_usage_t cons_usage,
-                                         const gralloc1_rect_t *region, void **out_data,
-                                         int32_t acquire_fence) {
-  ATRACE_CALL();
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status != GRALLOC1_ERROR_NONE || !out_data ||
-      !region) {  // currently we ignore the region/rect client wants to lock
-    CloseFdIfValid(acquire_fence);
-    return status;
-  }
-
-  if (acquire_fence > 0) {
-    ATRACE_BEGIN("fence wait");
-    int error = sync_wait(acquire_fence, 1000);
-    ATRACE_END();
-    CloseFdIfValid(acquire_fence);
-    if (error < 0) {
-      ALOGE("%s: sync_wait timedout! error = %s", __FUNCTION__, strerror(errno));
-      return GRALLOC1_ERROR_UNDEFINED;
-    }
-  }
-
-  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-
-  // Either producer usage or consumer usage must be *_USAGE_NONE
-  if ((prod_usage != GRALLOC1_PRODUCER_USAGE_NONE) &&
-      (cons_usage != GRALLOC1_CONSUMER_USAGE_NONE)) {
-    // Current gralloc1 clients do not satisfy this restriction.
-    // See b/33588773 for details
-    // return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  // TODO(user): Need to check if buffer was allocated with the same flags
-  status = dev->buf_mgr_->LockBuffer(hnd, prod_usage, cons_usage);
-  *out_data = reinterpret_cast<void *>(hnd->base);
-
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::LockFlex(gralloc1_device_t *device, buffer_handle_t buffer,
-                                       gralloc1_producer_usage_t prod_usage,
-                                       gralloc1_consumer_usage_t cons_usage,
-                                       const gralloc1_rect_t *region,
-                                       struct android_flex_layout *out_flex_layout,
-                                       int32_t acquire_fence) {
-  if (!out_flex_layout) {
-    CloseFdIfValid(acquire_fence);
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  void *out_data {};
-  gralloc1_error_t status = GrallocImpl::LockBuffer(device, buffer, prod_usage, cons_usage, region,
-                                                    &out_data, acquire_fence);
-  if (status != GRALLOC1_ERROR_NONE) {
-    return status;
-  }
-
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-  dev->buf_mgr_->GetFlexLayout(hnd, out_flex_layout);
-  return status;
-}
-
-gralloc1_error_t GrallocImpl::UnlockBuffer(gralloc1_device_t *device, buffer_handle_t buffer,
-                                           int32_t *release_fence) {
-  gralloc1_error_t status = CheckDeviceAndHandle(device, buffer);
-  if (status != GRALLOC1_ERROR_NONE) {
-    return status;
-  }
-
-  if (!release_fence) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  const private_handle_t *hnd = PRIV_HANDLE_CONST(buffer);
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-
-  *release_fence = -1;
-
-  return dev->buf_mgr_->UnlockBuffer(hnd);
-}
-
-gralloc1_error_t GrallocImpl::Gralloc1Perform(gralloc1_device_t *device, int operation, ...) {
-  if (!device) {
-    return GRALLOC1_ERROR_BAD_VALUE;
-  }
-
-  va_list args;
-  va_start(args, operation);
-  GrallocImpl const *dev = GRALLOC_IMPL(device);
-  gralloc1_error_t err = dev->buf_mgr_->Perform(operation, args);
-  va_end(args);
-
-  return err;
-}
-
-}  // namespace gralloc1
diff --git a/liblight/lights.c b/liblight/lights.c
index 115b98c..d511395 100644
--- a/liblight/lights.c
+++ b/liblight/lights.c
@@ -19,7 +19,7 @@
 
 // #define LOG_NDEBUG 0
 
-#include <cutils/log.h>
+#include <log/log.h>
 #include <cutils/properties.h>
 #include <stdint.h>
 #include <stdlib.h>
diff --git a/libqdutils/qdMetaData.cpp b/libqdutils/qdMetaData.cpp
index 3ccbc99..5c39133 100644
--- a/libqdutils/qdMetaData.cpp
+++ b/libqdutils/qdMetaData.cpp
@@ -30,7 +30,7 @@
 #include <errno.h>
 #include <string.h>
 #include <sys/mman.h>
-#include <cutils/log.h>
+#include <log/log.h>
 #include <cinttypes>
 #include <gralloc_priv.h>
 #include "qdMetaData.h"
diff --git a/libqdutils/qd_utils.h b/libqdutils/qd_utils.h
index f3b0c04..d83f273 100644
--- a/libqdutils/qd_utils.h
+++ b/libqdutils/qd_utils.h
@@ -35,7 +35,7 @@
 #include <ctype.h>
 #include <fcntl.h>
 #include <utils/Errors.h>
-#include <utils/Log.h>
+#include <log/log.h>
 
 #include <linux/fb.h>
 #include <sys/ioctl.h>
diff --git a/libqservice/IQHDMIClient.cpp b/libqservice/IQHDMIClient.cpp
index 9f5044a..6379e57 100644
--- a/libqservice/IQHDMIClient.cpp
+++ b/libqservice/IQHDMIClient.cpp
@@ -26,7 +26,7 @@
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
-#include <utils/Log.h>
+#include <log/log.h>
 #include <binder/Parcel.h>
 #include "IQHDMIClient.h"
 
diff --git a/libqservice/QService.h b/libqservice/QService.h
index bd130fa..6bb4d7d 100644
--- a/libqservice/QService.h
+++ b/libqservice/QService.h
@@ -32,7 +32,7 @@
 
 #include <utils/Errors.h>
 #include <sys/types.h>
-#include <cutils/log.h>
+#include <log/log.h>
 #include <binder/IServiceManager.h>
 #include <IQService.h>
 #include <IQClient.h>
diff --git a/sdm/libs/hwc2/Android.mk b/sdm/libs/hwc2/Android.mk
index 04992dc..0e839ce 100644
--- a/sdm/libs/hwc2/Android.mk
+++ b/sdm/libs/hwc2/Android.mk
@@ -18,9 +18,11 @@
 LOCAL_CLANG                   := true
 
 LOCAL_SHARED_LIBRARIES        := libsdmcore libqservice libbinder libhardware libhardware_legacy \
-                                 libutils libcutils libsync libqdutils libqdMetaData libdl \
+                                 libutils libcutils libsync libqdutils libqdMetaData \
                                  libsdmutils libc++ liblog libgrallocutils libui libgpu_tonemapper \
-                                 libhidlbase libhidltransport vendor.display.config@1.0
+                                 libhidlbase libhidltransport vendor.display.config@1.0 \
+                                 android.hardware.graphics.mapper@2.0\
+                                 android.hardware.graphics.allocator@2.0
 
 ifeq ($(display_config_version), DISPLAY_CONFIG_1_1)
 LOCAL_SHARED_LIBRARIES        += vendor.display.config@1.1
diff --git a/sdm/libs/hwc2/hwc_buffer_allocator.cpp b/sdm/libs/hwc2/hwc_buffer_allocator.cpp
index 84fbd80..0ebd9a4 100644
--- a/sdm/libs/hwc2/hwc_buffer_allocator.cpp
+++ b/sdm/libs/hwc2/hwc_buffer_allocator.cpp
@@ -33,75 +33,43 @@
 #include <utils/constants.h>
 #include <utils/debug.h>
 
+#include "gr_utils.h"
 #include "hwc_buffer_allocator.h"
 #include "hwc_debugger.h"
-#include "gr_utils.h"
 
 #define __CLASS__ "HWCBufferAllocator"
 
+using android::hardware::graphics::common::V1_0::PixelFormat;
+using android::hardware::graphics::mapper::V2_0::BufferDescriptor;
+using android::hardware::graphics::mapper::V2_0::Error;
+using android::hardware::hidl_handle;
+using android::hardware::hidl_vec;
+
 namespace sdm {
 
-DisplayError HWCBufferAllocator::Init() {
-  int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module_);
-  if (err != 0) {
-    DLOGE("FATAL: can not get GRALLOC module");
-    return kErrorResources;
+DisplayError HWCBufferAllocator::GetGrallocInstance() {
+  // Lazy initialization of gralloc HALs
+  if (mapper_ != nullptr || allocator_ != nullptr) {
+    return kErrorNone;
   }
 
-  err = gralloc1_open(module_, &gralloc_device_);
-  if (err != 0) {
-    DLOGE("FATAL: can not open GRALLOC device");
-    return kErrorResources;
-  }
+  allocator_ = IAllocator::getService();
+  mapper_ = IMapper::getService();
 
-  if (gralloc_device_ == nullptr) {
-    DLOGE("FATAL: gralloc device is null");
-    return kErrorResources;
-  }
-
-  CreateBufferDescriptor_ = reinterpret_cast<GRALLOC1_PFN_CREATE_DESCRIPTOR>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_CREATE_DESCRIPTOR));
-  DestroyBufferDescriptor_ = reinterpret_cast<GRALLOC1_PFN_DESTROY_DESCRIPTOR>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_DESTROY_DESCRIPTOR));
-  AllocateBuffer_ = reinterpret_cast<GRALLOC1_PFN_ALLOCATE>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_ALLOCATE));
-  ReleaseBuffer_ = reinterpret_cast<GRALLOC1_PFN_RELEASE>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_RELEASE));
-  SetBufferDimensions_ = reinterpret_cast<GRALLOC1_PFN_SET_DIMENSIONS>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_SET_DIMENSIONS));
-  SetBufferFormat_ = reinterpret_cast<GRALLOC1_PFN_SET_FORMAT>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_SET_FORMAT));
-  SetConsumerUsage_ = reinterpret_cast<GRALLOC1_PFN_SET_CONSUMER_USAGE>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_SET_CONSUMER_USAGE));
-  SetProducerUsage_ = reinterpret_cast<GRALLOC1_PFN_SET_PRODUCER_USAGE>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_SET_PRODUCER_USAGE));
-  LockBuffer_ = reinterpret_cast<GRALLOC1_PFN_LOCK>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_LOCK));
-  UnlockBuffer_ = reinterpret_cast<GRALLOC1_PFN_UNLOCK>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_UNLOCK));
-  Perform_ = reinterpret_cast<GRALLOC1_PFN_PERFORM>(
-      gralloc_device_->getFunction(gralloc_device_, GRALLOC1_FUNCTION_PERFORM));
-
-  return kErrorNone;
-}
-
-DisplayError HWCBufferAllocator::Deinit() {
-  if (gralloc_device_ != nullptr) {
-    int err = gralloc1_close(gralloc_device_);
-    if (err != 0) {
-      DLOGE("FATAL: can not close GRALLOC device");
-      return kErrorResources;
-    }
+  if (mapper_ == nullptr || allocator_ == nullptr) {
+    DLOGE("Unable to get mapper or allocator");
+    return kErrorCriticalResource;
   }
   return kErrorNone;
 }
 
 DisplayError HWCBufferAllocator::AllocateBuffer(BufferInfo *buffer_info) {
-  DisplayError sdm_err = kErrorNone;
+  auto err = GetGrallocInstance();
+  if (err != kErrorNone) {
+    return err;
+  }
   const BufferConfig &buffer_config = buffer_info->buffer_config;
   AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
-  uint32_t width = buffer_config.width;
-  uint32_t height = buffer_config.height;
   int format;
   uint64_t alloc_flags = 0;
   int error = SetBufferInfo(buffer_config.format, &format, &alloc_flags);
@@ -110,11 +78,11 @@
   }
 
   if (buffer_config.secure) {
-    alloc_flags |= GRALLOC1_PRODUCER_USAGE_PROTECTED;
+    alloc_flags |= BufferUsage::PROTECTED;
   }
 
   if (buffer_config.secure_camera) {
-    alloc_flags |= GRALLOC1_PRODUCER_USAGE_CAMERA;
+    alloc_flags |= BufferUsage::CAMERA_OUTPUT;
   }
 
   if (!buffer_config.cache) {
@@ -123,45 +91,51 @@
   }
 
   if (buffer_config.gfx_client) {
-    alloc_flags |= GRALLOC1_CONSUMER_USAGE_GPU_TEXTURE;
+    alloc_flags |= BufferUsage::GPU_TEXTURE;
   }
 
-  gralloc1_producer_usage_t producer_usage = static_cast<gralloc1_producer_usage_t>(alloc_flags);
-  gralloc1_consumer_usage_t consumer_usage = static_cast<gralloc1_consumer_usage_t>(alloc_flags |
-                                             GRALLOC1_CONSUMER_USAGE_HWCOMPOSER);
-  gralloc1_buffer_descriptor_t descriptor_id = {};
-  buffer_handle_t buf = nullptr;
+  alloc_flags |= BufferUsage::COMPOSER_OVERLAY;
+
+  IMapper::BufferDescriptorInfo descriptor_info;
+  descriptor_info.width = buffer_config.width;
+  descriptor_info.height = buffer_config.height;
+  descriptor_info.layerCount = 1;
+  descriptor_info.format = static_cast<PixelFormat>(format);
+  descriptor_info.usage = alloc_flags;
+  auto descriptor = BufferDescriptor();
+  auto hidl_err = Error::NONE;
+
+  mapper_->createDescriptor(descriptor_info, [&](const auto &_error, const auto &_descriptor) {
+    hidl_err = _error;
+    descriptor = _descriptor;
+  });
+  if (hidl_err != Error::NONE) {
+    DLOGE("Failed to create descriptor");
+    return kErrorMemory;
+  }
+
+  hidl_handle raw_handle = nullptr;
   private_handle_t *hnd = nullptr;
 
-  // CreateBuffer
-  if (CreateBufferDescriptor_(gralloc_device_, &descriptor_id) != GRALLOC1_ERROR_NONE) {
-    DLOGE("CreateBufferDescriptor failed gr_device=%p", gralloc_device_);
-    return kErrorParameters;
+  allocator_->allocate(descriptor, 1,
+                       [&](const auto &_error, const auto &_stride, const auto &_buffers) {
+                         hidl_err = _error;
+                         raw_handle = _buffers[0];
+                       });
+  if (hidl_err != Error::NONE) {
+    DLOGE("Failed to allocate buffer");
+    return kErrorMemory;
   }
-  if (SetBufferDimensions_(gralloc_device_, descriptor_id, width, height) != GRALLOC1_ERROR_NONE) {
-    DLOGE("SetBufferDimensions failed gr_device=%x desc=%d", gralloc_device_, descriptor_id);
-    sdm_err = kErrorParameters;
-    goto CleanupOnError;
-  }
-  if (SetBufferFormat_(gralloc_device_, descriptor_id, format) != GRALLOC1_ERROR_NONE) {
-    DLOGE("SetBufferFormat failed gr_device=%x desc=%d", gralloc_device_, descriptor_id);
-    sdm_err = kErrorParameters;
-    goto CleanupOnError;
-  }
-  if (SetConsumerUsage_(gralloc_device_, descriptor_id, consumer_usage) != GRALLOC1_ERROR_NONE) {
-    DLOGE("SetConsumerUsage failed gr_device=%x desc=%d", gralloc_device_, descriptor_id);
-    sdm_err = kErrorParameters;
-    goto CleanupOnError;
-  }
-  if (SetProducerUsage_(gralloc_device_, descriptor_id, producer_usage) != GRALLOC1_ERROR_NONE) {
-    DLOGE("SetProducerUsage failed gr_device=%x desc=%d", gralloc_device_, descriptor_id);
-    sdm_err = kErrorParameters;
-    goto CleanupOnError;
-  }
-  if (AllocateBuffer_(gralloc_device_, 1, &descriptor_id, &buf) != GRALLOC1_ERROR_NONE) {
-    DLOGE("AllocateBuffer failed gr_device=%x desc=%d", gralloc_device_, descriptor_id);
-    sdm_err = kErrorMemory;
-    goto CleanupOnError;
+
+  const native_handle_t *buf = nullptr;
+  mapper_->importBuffer(raw_handle, [&](const auto &_error, const auto &_buffer) {
+    hidl_err = _error;
+    buf = static_cast<const native_handle_t *>(_buffer);
+  });
+
+  if (hidl_err != Error::NONE) {
+    DLOGE("Failed to import buffer into HWC");
+    return kErrorMemory;
   }
 
   hnd = (private_handle_t *)buf;  // NOLINT
@@ -172,45 +146,45 @@
   alloc_buffer_info->size = hnd->size;
 
   buffer_info->private_data = reinterpret_cast<void *>(hnd);
-CleanupOnError:
-  DestroyBufferDescriptor_(gralloc_device_, descriptor_id);
-  return sdm_err;
+  return kErrorNone;
 }
 
 DisplayError HWCBufferAllocator::FreeBuffer(BufferInfo *buffer_info) {
   DisplayError err = kErrorNone;
-  buffer_handle_t hnd = static_cast<buffer_handle_t>(buffer_info->private_data);
-  ReleaseBuffer_(gralloc_device_, hnd);
-  AllocatedBufferInfo *alloc_buffer_info = &buffer_info->alloc_buffer_info;
+  auto hnd = reinterpret_cast<void *>(buffer_info->private_data);
+  mapper_->freeBuffer(hnd);
+  AllocatedBufferInfo &alloc_buffer_info = buffer_info->alloc_buffer_info;
 
-  alloc_buffer_info->fd = -1;
-  alloc_buffer_info->stride = 0;
-  alloc_buffer_info->size = 0;
+  alloc_buffer_info.fd = -1;
+  alloc_buffer_info.stride = 0;
+  alloc_buffer_info.size = 0;
   buffer_info->private_data = NULL;
   return err;
 }
 
 void HWCBufferAllocator::GetCustomWidthAndHeight(const private_handle_t *handle, int *width,
                                                  int *height) {
-  Perform_(gralloc_device_, GRALLOC_MODULE_PERFORM_GET_CUSTOM_STRIDE_AND_HEIGHT_FROM_HANDLE, handle,
-           width, height);
+  *width = handle->width;
+  *height = handle->height;
+  gralloc::GetCustomDimensions(const_cast<private_handle_t *>(handle), width, height);
 }
 
 void HWCBufferAllocator::GetAlignedWidthAndHeight(int width, int height, int format,
                                                   uint32_t alloc_type, int *aligned_width,
                                                   int *aligned_height) {
-  int tile_enabled;
-  gralloc1_producer_usage_t producer_usage = GRALLOC1_PRODUCER_USAGE_NONE;
-  gralloc1_consumer_usage_t consumer_usage = GRALLOC1_CONSUMER_USAGE_NONE;
+  uint64_t usage = 0;
   if (alloc_type & GRALLOC_USAGE_HW_FB) {
-    consumer_usage = GRALLOC1_CONSUMER_USAGE_CLIENT_TARGET;
+    usage |= BufferUsage::COMPOSER_CLIENT_TARGET;
   }
   if (alloc_type & GRALLOC_USAGE_PRIVATE_ALLOC_UBWC) {
-    producer_usage = GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
+    usage |= GRALLOC_USAGE_PRIVATE_ALLOC_UBWC;
   }
-
-  Perform_(gralloc_device_, GRALLOC_MODULE_PERFORM_GET_ATTRIBUTES, width, height, format,
-           producer_usage, consumer_usage, aligned_width, aligned_height, &tile_enabled);
+  uint32_t aligned_w = UINT(width);
+  uint32_t aligned_h = UINT(height);
+  gralloc::BufferInfo info(width, height, format, usage);
+  gralloc::GetAlignedWidthAndHeight(info, &aligned_w, &aligned_h);
+  *aligned_width = INT(aligned_w);
+  *aligned_height = INT(aligned_h);
 }
 
 uint32_t HWCBufferAllocator::GetBufferSize(BufferInfo *buffer_info) {
@@ -235,12 +209,7 @@
   }
 
   uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0;
-  gralloc1_producer_usage_t producer_usage = GRALLOC1_PRODUCER_USAGE_NONE;
-  gralloc1_consumer_usage_t consumer_usage = GRALLOC1_CONSUMER_USAGE_NONE;
-  // TODO(user): Currently both flags are treated similarly in gralloc
-  producer_usage = gralloc1_producer_usage_t(alloc_flags);
-  consumer_usage = gralloc1_consumer_usage_t(alloc_flags);
-  gralloc1::BufferInfo info(width, height, format, producer_usage, consumer_usage);
+  gralloc::BufferInfo info(width, height, format, alloc_flags);
   GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
   return buffer_size;
 }
@@ -394,12 +363,7 @@
   }
 
   uint32_t aligned_width = 0, aligned_height = 0, buffer_size = 0;
-  gralloc1_producer_usage_t producer_usage = GRALLOC1_PRODUCER_USAGE_NONE;
-  gralloc1_consumer_usage_t consumer_usage = GRALLOC1_CONSUMER_USAGE_NONE;
-  // TODO(user): Currently both flags are treated similarly in gralloc
-  producer_usage = gralloc1_producer_usage_t(alloc_flags);
-  consumer_usage = gralloc1_consumer_usage_t(alloc_flags);
-  gralloc1::BufferInfo info(width, height, format, producer_usage, consumer_usage);
+  gralloc::BufferInfo info(width, height, format, alloc_flags);
   GetBufferSizeAndDimensions(info, &buffer_size, &aligned_width, &aligned_height);
   allocated_buffer_info->stride = UINT32(aligned_width);
   allocated_buffer_info->aligned_width = UINT32(aligned_width);
@@ -426,7 +390,7 @@
     hnd.flags = private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
   }
 
-  int ret = gralloc1::GetBufferLayout(&hnd, stride, offset, num_planes);
+  int ret = gralloc::GetBufferLayout(&hnd, stride, offset, num_planes);
   if (ret < 0) {
     DLOGE("GetBufferLayout failed");
     return kErrorParameters;
@@ -436,24 +400,42 @@
 }
 
 DisplayError HWCBufferAllocator::MapBuffer(const private_handle_t *handle, int acquire_fence) {
-  void* buffer_ptr = NULL;
-  const gralloc1_rect_t accessRegion = {
-        .left = 0,
-        .top = 0,
-        .width = 0,
-        .height = 0
-  };
-  LockBuffer_(gralloc_device_, handle, GRALLOC1_PRODUCER_USAGE_CPU_READ,
-              GRALLOC1_CONSUMER_USAGE_NONE, &accessRegion, &buffer_ptr, acquire_fence);
+  void *buffer_ptr = NULL;
+  const IMapper::Rect access_region = {.left = 0, .top = 0, .width = 0, .height = 0};
+
+  NATIVE_HANDLE_DECLARE_STORAGE(acquire_fence_storage, 1, 0);
+  hidl_handle acquire_fence_handle;
+  if (acquire_fence >= 0) {
+    auto h = native_handle_init(acquire_fence_storage, 1, 0);
+    h->data[0] = acquire_fence;
+    acquire_fence_handle = h;
+  }
+
+  auto hnd = const_cast<private_handle_t *>(handle);
+  mapper_->lock(reinterpret_cast<void *>(hnd), (uint64_t)BufferUsage::CPU_READ_OFTEN,
+                access_region, acquire_fence_handle, [&](const auto &_error, const auto &_buffer) {
+                  if (_error == Error::NONE) {
+                    buffer_ptr = _buffer;
+                  }
+                });
+
   if (!buffer_ptr) {
     return kErrorUndefined;
   }
-
   return kErrorNone;
 }
 
-DisplayError HWCBufferAllocator::UnmapBuffer(const private_handle_t *handle, int* release_fence) {
-  return (DisplayError)(UnlockBuffer_(gralloc_device_, handle, release_fence));
+DisplayError HWCBufferAllocator::UnmapBuffer(const private_handle_t *handle, int *release_fence) {
+  DisplayError err = kErrorNone;
+  *release_fence = -1;
+  auto hnd = const_cast<private_handle_t *>(handle);
+  mapper_->unlock(reinterpret_cast<void *>(hnd),
+                  [&](const auto &_error, const auto &_release_fence) {
+                    if (_error != Error::NONE) {
+                      err = kErrorUndefined;
+                    }
+                  });
+  return err;
 }
 
 }  // namespace sdm
diff --git a/sdm/libs/hwc2/hwc_buffer_allocator.h b/sdm/libs/hwc2/hwc_buffer_allocator.h
index 7df88a4..d6f251f 100644
--- a/sdm/libs/hwc2/hwc_buffer_allocator.h
+++ b/sdm/libs/hwc2/hwc_buffer_allocator.h
@@ -1,41 +1,44 @@
 /*
-* Copyright (c) 2015-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
-* met:
-*  * Redistributions of source code must retain the above copyright
-*    notice, this list of conditions and the following disclaimer.
-*  * Redistributions in binary form must reproduce the above
-*    copyright notice, this list of conditions and the following
-*    disclaimer in the documentation and/or other materials provided
-*    with the distribution.
-*  * Neither the name of The Linux Foundation nor the names of its
-*    contributors may be used to endorse or promote products derived
-*    from this software without specific prior written permission.
-*
-* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
-* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
-* ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
-* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-#ifdef USE_GRALLOC1
+ * Copyright (c) 2015-2018, 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
+ * met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above
+ *    copyright notice, this list of conditions and the following
+ *    disclaimer in the documentation and/or other materials provided
+ *    with the distribution.
+ *  * Neither the name of The Linux Foundation nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
+ * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+ * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
 #ifndef __HWC_BUFFER_ALLOCATOR_H__
 #define __HWC_BUFFER_ALLOCATOR_H__
 
 #include <fcntl.h>
 #include <sys/mman.h>
 
-#include <hardware/gralloc1.h>
+#include <android/hardware/graphics/allocator/2.0/IAllocator.h>
+#include <android/hardware/graphics/mapper/2.0/IMapper.h>
 #include "gralloc_priv.h"
 
+using android::hardware::graphics::allocator::V2_0::IAllocator;
+using android::hardware::graphics::mapper::V2_0::IMapper;
+
 namespace sdm {
 
 template <class Type>
@@ -45,8 +48,6 @@
 
 class HWCBufferAllocator : public BufferAllocator {
  public:
-  DisplayError Init();
-  DisplayError Deinit();
   DisplayError AllocateBuffer(BufferInfo *buffer_info);
   DisplayError FreeBuffer(BufferInfo *buffer_info);
   uint32_t GetBufferSize(BufferInfo *buffer_info);
@@ -56,32 +57,17 @@
                                 int *aligned_width, int *aligned_height);
   DisplayError GetAllocatedBufferInfo(const BufferConfig &buffer_config,
                                       AllocatedBufferInfo *allocated_buffer_info);
-  DisplayError GetBufferLayout(const AllocatedBufferInfo &buf_info,
-                               uint32_t stride[4], uint32_t offset[4],
-                               uint32_t *num_planes);
+  DisplayError GetBufferLayout(const AllocatedBufferInfo &buf_info, uint32_t stride[4],
+                               uint32_t offset[4], uint32_t *num_planes);
   int SetBufferInfo(LayerBufferFormat format, int *target, uint64_t *flags);
   DisplayError MapBuffer(const private_handle_t *handle, int acquire_fence);
-  DisplayError UnmapBuffer(const private_handle_t *handle, int* release_fence);
+  DisplayError UnmapBuffer(const private_handle_t *handle, int *release_fence);
 
  private:
-  gralloc1_device_t *gralloc_device_ = nullptr;
-  const hw_module_t *module_ = nullptr;
-  GRALLOC1_PFN_CREATE_DESCRIPTOR CreateBufferDescriptor_ = nullptr;
-  GRALLOC1_PFN_DESTROY_DESCRIPTOR DestroyBufferDescriptor_ = nullptr;
-  GRALLOC1_PFN_ALLOCATE AllocateBuffer_ = nullptr;
-  GRALLOC1_PFN_RELEASE ReleaseBuffer_ = nullptr;
-  GRALLOC1_PFN_SET_DIMENSIONS SetBufferDimensions_ = nullptr;
-  GRALLOC1_PFN_SET_FORMAT SetBufferFormat_ = nullptr;
-  GRALLOC1_PFN_SET_CONSUMER_USAGE SetConsumerUsage_ = nullptr;
-  GRALLOC1_PFN_SET_PRODUCER_USAGE SetProducerUsage_ = nullptr;
-  GRALLOC1_PFN_LOCK LockBuffer_ = nullptr;
-  GRALLOC1_PFN_UNLOCK UnlockBuffer_ = nullptr;
-  GRALLOC1_PFN_PERFORM Perform_ = nullptr;
+  DisplayError GetGrallocInstance();
+  android::sp<IMapper> mapper_;
+  android::sp<IAllocator> allocator_;
 };
 
 }  // namespace sdm
 #endif  // __HWC_BUFFER_ALLOCATOR_H__
-#else
-#include "../hwc/hwc_buffer_allocator.h"
-#endif  // __HWC_BUFFER_ALLOCATOR_H__
-
diff --git a/sdm/libs/hwc2/hwc_debugger.h b/sdm/libs/hwc2/hwc_debugger.h
index 04cbfa7..3a3d787 100644
--- a/sdm/libs/hwc2/hwc_debugger.h
+++ b/sdm/libs/hwc2/hwc_debugger.h
@@ -34,7 +34,7 @@
 
 #include <core/sdm_types.h>
 #include <core/debug_interface.h>
-#include <cutils/log.h>
+#include <log/log.h>
 #include <utils/Trace.h>
 #include <bitset>
 
diff --git a/sdm/libs/hwc2/hwc_display.cpp b/sdm/libs/hwc2/hwc_display.cpp
index e42ed41..91e47ef 100644
--- a/sdm/libs/hwc2/hwc_display.cpp
+++ b/sdm/libs/hwc2/hwc_display.cpp
@@ -42,10 +42,6 @@
 #include "hwc_tonemapper.h"
 #include "hwc_session.h"
 
-#ifndef USE_GRALLOC1
-#include <gr.h>
-#endif
-
 #ifdef QTI_BSP
 #include <hardware/display_defs.h>
 #endif
@@ -547,11 +543,7 @@
     const private_handle_t *handle =
         reinterpret_cast<const private_handle_t *>(layer->input_buffer.buffer_id);
     if (handle) {
-#ifdef USE_GRALLOC1
       if (handle->buffer_type == BUFFER_TYPE_VIDEO) {
-#else
-      if (handle->bufferType == BUFFER_TYPE_VIDEO) {
-#endif
         layer_stack_.flags.video_present = true;
       }
       // TZ Protected Buffer - L1
@@ -1724,13 +1716,8 @@
     flags |= private_handle_t::PRIV_FLAGS_UBWC_ALIGNED;
   }
 
-#ifdef USE_GRALLOC1
   buffer_allocator_->GetAlignedWidthAndHeight(INT(x_pixels), INT(y_pixels), format, usage,
                                               &aligned_width, &aligned_height);
-#else
-  AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(INT(x_pixels), INT(y_pixels), format,
-                                                        INT(usage), aligned_width, aligned_height);
-#endif
 
   // TODO(user): How does the dirty region get set on the client target? File bug on Google
   client_target_layer->composition = kCompositionGPUTarget;
diff --git a/sdm/libs/hwc2/hwc_display_virtual.cpp b/sdm/libs/hwc2/hwc_display_virtual.cpp
index e1949ba..11193bb 100644
--- a/sdm/libs/hwc2/hwc_display_virtual.cpp
+++ b/sdm/libs/hwc2/hwc_display_virtual.cpp
@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2014-2017, The Linux Foundation. All rights reserved.
+* Copyright (c) 2014-2018, 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
@@ -31,9 +31,6 @@
 #include <utils/debug.h>
 #include <sync/sync.h>
 #include <stdarg.h>
-#ifndef USE_GRALLOC1
-#include <gr.h>
-#endif
 
 #include "hwc_display_virtual.h"
 #include "hwc_debugger.h"
diff --git a/sdm/libs/hwc2/hwc_layers.cpp b/sdm/libs/hwc2/hwc_layers.cpp
index 0f860d8..96e7499 100644
--- a/sdm/libs/hwc2/hwc_layers.cpp
+++ b/sdm/libs/hwc2/hwc_layers.cpp
@@ -17,16 +17,12 @@
  * limitations under the License.
  */
 
+#include "hwc_layers.h"
+#include <utils/debug.h>
 #include <stdint.h>
 #include <utility>
-#include <qdMetaData.h>
-
-#include "hwc_layers.h"
-#ifndef USE_GRALLOC1
-#include <gr.h>
-#endif
-#include <utils/debug.h>
 #include <cmath>
+#include <qdMetaData.h>
 
 #define __CLASS__ "HWCLayer"
 
@@ -220,11 +216,7 @@
 
   LayerBuffer *layer_buffer = &layer_->input_buffer;
   int aligned_width, aligned_height;
-#ifdef USE_GRALLOC1
   buffer_allocator_->GetCustomWidthAndHeight(handle, &aligned_width, &aligned_height);
-#else
-  AdrenoMemInfo::getInstance().getAlignedWidthAndHeight(handle, aligned_width, aligned_height);
-#endif
 
   LayerBufferFormat format = GetSDMFormat(handle->format, handle->flags);
   if ((format != layer_buffer->format) || (UINT32(aligned_width) != layer_buffer->width) ||
diff --git a/sdm/libs/hwc2/hwc_session.cpp b/sdm/libs/hwc2/hwc_session.cpp
index 4302bd9..8a69776 100644
--- a/sdm/libs/hwc2/hwc_session.cpp
+++ b/sdm/libs/hwc2/hwc_session.cpp
@@ -162,13 +162,7 @@
   StartServices();
 
   HWCDebugHandler::Get()->GetProperty("sdm.debug.enable_null_display", &null_display_mode_);
-
-  DisplayError error = buffer_allocator_.Init();
-  if (error != kErrorNone) {
-    ALOGE("%s::%s: Buffer allocator initialization failed. Error = %d",
-          __CLASS__, __FUNCTION__, error);
-    return -EINVAL;
-  }
+  DisplayError error = kErrorNone;
 
   HWDisplayInterfaceInfo hw_disp_info = {};
   if (null_display_mode_) {
@@ -180,19 +174,11 @@
     error = CoreInterface::CreateCore(HWCDebugHandler::Get(), &buffer_allocator_,
                                       &buffer_sync_handler_, &socket_handler_, &core_intf_);
 
-    if (error != kErrorNone) {
-      buffer_allocator_.Deinit();
-      ALOGE("%s::%s: Display core initialization failed. Error = %d", __CLASS__, __FUNCTION__,
-            error);
-      return -EINVAL;
-    }
-
     error = core_intf_->GetFirstDisplayInterfaceType(&hw_disp_info);
 
     if (error != kErrorNone) {
       g_hwc_uevent_.Register(nullptr);
       CoreInterface::DestroyCore();
-      buffer_allocator_.Deinit();
       DLOGE("Primary display type not recognized. Error = %d", error);
       return -EINVAL;
     }
@@ -219,7 +205,6 @@
   if (status) {
     g_hwc_uevent_.Register(nullptr);
     CoreInterface::DestroyCore();
-    buffer_allocator_.Deinit();
     return status;
   }