libvendorgraphicbuffer/gralloc4/vendor_graphicbuffer_meta.cpp - platform/hardware/google/gchips - Git at Google

 /*
  * Copyright (C) 2020 Samsung Electronics Co. Ltd.
  *
  * 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 LOG_TAG "VendorGraphicBuffer"

 #include <log/log.h>
 #include <gralloctypes/Gralloc4.h>
 #include <android/hardware/graphics/mapper/4.0/IMapper.h>

 #include "VendorGraphicBuffer.h"
 #include "mali_gralloc_buffer.h"
 #include "mali_gralloc_formats.h"
 #include "hidl_common/SharedMetadata.h"
 #include "hidl_common/SharedMetadata_struct.h"
 #include "hidl_common/hidl_common.h"
 #include "exynos_format.h"

 #include <pixel-gralloc/metadata.h>
 #include <pixel-gralloc/mapper.h>

 using namespace android;
 using namespace vendor::graphics;

 using arm::mapper::common::shared_metadata;
 using aidl::android::hardware::graphics::common::Dataspace;
 using android::gralloc4::encodeDataspace;
 using android::gralloc4::decodeDataspace;
 using android::gralloc4::decodePixelFormatFourCC;
 using android::gralloc4::decodePixelFormatModifier;
 using android::hardware::graphics::mapper::V4_0::IMapper;
 using android::hardware::graphics::mapper::V4_0::Error;
 using MapperMetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;

 #define UNUSED(x) ((void)x)
 #define SZ_4k 0x1000

 // TODO(b/191912915): This is a non-thread safe version of the validate function
 // from mapper-4.0-impl library. Ideally this should be decoupled from `impl`
 // libraries and should depend upon HAL (and it's extension) to call into
 // Gralloc.
 int mali_gralloc_reference_validate(buffer_handle_t handle) {
 	return private_handle_t::validate(handle);
 }

 const private_handle_t * convertNativeHandleToPrivateHandle(buffer_handle_t handle) {
 	if (mali_gralloc_reference_validate(handle) < 0)
 		return nullptr;

 	return static_cast<const private_handle_t *>(handle);
 }

 android::sp<IMapper> get_mapper() {
 	static android::sp<IMapper> mapper = []() {
 		auto mapper = IMapper::getService();
 		if (!mapper) {
 			ALOGE("Failed to get mapper service");
 		}
 		return mapper;
 	}();

 	return mapper;
 }

 int VendorGraphicBufferMeta::get_video_metadata_fd(buffer_handle_t /*hnd*/)
 {
 	ALOGE("%s function is obsolete and should not be used", __FUNCTION__);
 	__builtin_trap();
 }

 int VendorGraphicBufferMeta::get_dataspace(buffer_handle_t hnd)
 {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return -EINVAL;
 	}

 	Error error = Error::NONE;
 	Dataspace dataspace;
 	get_mapper()->get(handle, android::gralloc4::MetadataType_Dataspace,
 	                  [&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
 	                  	error = tmpError;
 	                  	if (error != Error::NONE) {
 	                  		return;
 	                  	}
 	                  	error = static_cast<Error>(decodeDataspace(tmpVec, &dataspace));
 	                  });


 	if (error != Error::NONE) {
 		ALOGE("Failed to get datasapce");
 		return -EINVAL;
 	}

 	return static_cast<int>(dataspace);
 }

 int VendorGraphicBufferMeta::set_dataspace(buffer_handle_t hnd, android_dataspace_t dataspace)
 {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return -EINVAL;
 	}

 	Error error = Error::NONE;
 	android::hardware::hidl_vec<uint8_t> vec;
 	error = static_cast<Error>(encodeDataspace(static_cast<Dataspace>(dataspace), &vec));
 	if (error != Error::NONE) {
 		ALOGE("Error encoding dataspace");
 		return -EINVAL;
 	}
 	error = get_mapper()->set(handle, android::gralloc4::MetadataType_Dataspace, vec);

 	if (error != Error::NONE) {
 		ALOGE("Failed to set datasapce");
 		return -EINVAL;
 	}

 	return 0;
 }

 int VendorGraphicBufferMeta::is_afbc(buffer_handle_t hnd)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

 	if (!gralloc_hnd)
 		return 0;

 	if (gralloc_hnd->alloc_format & MALI_GRALLOC_INTFMT_AFBCENABLE_MASK)
 		return 1;

 	return 0;
 }

 int VendorGraphicBufferMeta::is_sbwc(buffer_handle_t hnd)
 {
 	return is_sbwc_format(VendorGraphicBufferMeta::get_internal_format(hnd));
 }

 #define GRALLOC_META_GETTER(__type__, __name__, __member__) \
 __type__ VendorGraphicBufferMeta::get_##__name__(buffer_handle_t hnd) \
 { \
 	const private_handle_t *gralloc_hnd = static_cast<const private_handle_t *>(hnd); \
 	if (!gralloc_hnd) return 0; \
 	return gralloc_hnd->__member__; \
 } \


 uint32_t VendorGraphicBufferMeta::get_format(buffer_handle_t hnd)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

 	if (!gralloc_hnd)
 		return 0;

 	return static_cast<uint32_t>(gralloc_hnd->alloc_format);
 }

 uint64_t VendorGraphicBufferMeta::get_internal_format(buffer_handle_t hnd)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);;

 	if (!gralloc_hnd)
 		return 0;

 	return static_cast<uint64_t>(gralloc_hnd->alloc_format & MALI_GRALLOC_INTFMT_FMT_MASK);
 }

 GRALLOC_META_GETTER(uint64_t, frameworkFormat, req_format);

 GRALLOC_META_GETTER(int, width, width);
 GRALLOC_META_GETTER(int, height, height);
 GRALLOC_META_GETTER(uint32_t, stride, stride);
 GRALLOC_META_GETTER(uint32_t, stride_in_bytes, plane_info[0].byte_stride);
 GRALLOC_META_GETTER(uint32_t, vstride, plane_info[0].alloc_height);

 GRALLOC_META_GETTER(uint64_t, producer_usage, producer_usage);
 GRALLOC_META_GETTER(uint64_t, consumer_usage, consumer_usage);

 GRALLOC_META_GETTER(uint64_t, flags, flags);


 int VendorGraphicBufferMeta::get_fd(buffer_handle_t hnd, int num)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

 	if (!gralloc_hnd)
 		return -1;

 	if (num > 2)
 		return -1;

 	return gralloc_hnd->fds[num];
 }

 int VendorGraphicBufferMeta::get_size(buffer_handle_t hnd, int num)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

 	if (!gralloc_hnd)
 		return 0;

 	if (num > 2)
 		return 0;

 	return gralloc_hnd->alloc_sizes[num];
 }


 uint64_t VendorGraphicBufferMeta::get_usage(buffer_handle_t hnd)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

 	if (!gralloc_hnd)
 		return 0;

 	return gralloc_hnd->producer_usage | gralloc_hnd->consumer_usage;
 }

 void* decodePointer(const android::hardware::hidl_vec<uint8_t>& tmpVec) {
 	constexpr uint8_t kPtrSize = sizeof(void*);
 	assert(tmpVec.size() == kPtrSize);

 	void* data_ptr;
 	std::memcpy(&data_ptr, tmpVec.data(), kPtrSize);

 	return data_ptr;
 }

 void* VendorGraphicBufferMeta::get_video_metadata(buffer_handle_t hnd)
 {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return nullptr;
 	}

 	using namespace ::pixel::graphics;
 	auto out_oe = mapper::get<MetadataType::VIDEO_HDR>(handle);

 	if (!out_oe.has_value()) {
 		ALOGE("Failed to get video HDR metadata");
 		return nullptr;
 	}

 	return out_oe.value();
 }

 void* VendorGraphicBufferMeta::get_video_metadata_roiinfo(buffer_handle_t hnd)
 {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return nullptr;
 	}

 	using namespace ::pixel::graphics;
 	auto out_oe = mapper::get<MetadataType::VIDEO_ROI>(handle);

 	if (!out_oe.has_value()) {
 		ALOGE("Failed to get video ROI metadata");
 		return nullptr;
 	}

 	return out_oe.value();
 }

 uint32_t VendorGraphicBufferMeta::get_format_fourcc(buffer_handle_t hnd) {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return DRM_FORMAT_INVALID;
 	}

 	Error error = Error::NONE;
 	uint32_t fourcc;
 	get_mapper()->get(handle, android::gralloc4::MetadataType_PixelFormatFourCC,
 	                  [&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
 	                  	error = tmpError;
 	                  	if (error != Error::NONE) {
 	                  		return;
 	                  	}
 	                  	error = static_cast<Error>(decodePixelFormatFourCC(tmpVec, &fourcc));
 	                  });


 	if (error != Error::NONE) {
 		ALOGE("Failed to get fourcc");
 		return DRM_FORMAT_INVALID;
 	}

 	return fourcc;
 }

 uint64_t VendorGraphicBufferMeta::get_format_modifier(buffer_handle_t hnd) {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return DRM_FORMAT_MOD_INVALID;
 	}

 	Error error = Error::NONE;
 	uint64_t modifier;
 	get_mapper()->get(handle, android::gralloc4::MetadataType_PixelFormatModifier,
 	                  [&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
 	                  	error = tmpError;
 	                  	if (error != Error::NONE) {
 	                  		return;
 	                  	}
 	                  	error = static_cast<Error>(decodePixelFormatModifier(tmpVec, &modifier));
 	                  });


 	if (error != Error::NONE) {
 		ALOGE("Failed to get format modifier");
 		return DRM_FORMAT_MOD_INVALID;
 	}

 	return modifier;
 }

 void VendorGraphicBufferMeta::init(const buffer_handle_t handle)
 {
 	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(handle);

 	if (!gralloc_hnd)
 		return;

 	fd = gralloc_hnd->fds[0];
 	fd1 = gralloc_hnd->fds[1];
 	fd2 = gralloc_hnd->fds[2];

 	size   = gralloc_hnd->alloc_sizes[0];
 	size1  = gralloc_hnd->alloc_sizes[1];
 	size2  = gralloc_hnd->alloc_sizes[2];

 	offsets[0] = gralloc_hnd->plane_info[0].offset;
 	offsets[1] = gralloc_hnd->plane_info[1].offset;
 	offsets[2] = gralloc_hnd->plane_info[2].offset;

 	uint64_t usage = gralloc_hnd->producer_usage | gralloc_hnd->consumer_usage;
 	if (usage & VendorGraphicBufferUsage::VIDEO_PRIVATE_DATA) {
 		switch (gralloc_hnd->get_share_attr_fd_index()) {
 		case 1:
 			size1 = gralloc_hnd->attr_size;
 			break;
 		case 2:
 			size2 = gralloc_hnd->attr_size;
 			break;
 		}
 	}

 	internal_format = gralloc_hnd->alloc_format;
 	frameworkFormat = gralloc_hnd->req_format;

 	width  = gralloc_hnd->width;
 	height = gralloc_hnd->height;
 	stride = gralloc_hnd->stride;
 	vstride = gralloc_hnd->plane_info[0].alloc_height;

 	producer_usage = gralloc_hnd->producer_usage;
 	consumer_usage = gralloc_hnd->consumer_usage;

 	flags = gralloc_hnd->flags;

 	unique_id = gralloc_hnd->backing_store_id;
 }

 buffer_handle_t VendorGraphicBufferMeta::import_buffer(buffer_handle_t hnd)
 {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return nullptr;
 	}

 	native_handle_t* bufferHandle = nullptr;
 	Error error = Error::NONE;
 	get_mapper()->importBuffer(handle, [&](const auto& tmpError, const auto& tmpBuffer) {
 				error = tmpError;
 				if (error != Error::NONE) {
 					return;
 				}
 				bufferHandle = static_cast<native_handle_t*>(tmpBuffer);
 			});

 	if (error != Error::NONE) {
 		ALOGE("[%s] Unable to import buffer", __FUNCTION__);
 		return nullptr;
 	}

 	return bufferHandle;
 }

 int VendorGraphicBufferMeta::free_buffer(buffer_handle_t hnd)
 {
 	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
 	if (!handle) {
 		return -EINVAL;
 	}
 	Error error = get_mapper()->freeBuffer(handle);
 	if (error != Error::NONE) {
 		ALOGE("[%s] Failed to free buffer", __FUNCTION__);
 		return -EINVAL;
 	}
 	return 0;
 }

 VendorGraphicBufferMeta::VendorGraphicBufferMeta(buffer_handle_t handle)
 {
 	init(handle);
 }
	/*
	* Copyright (C) 2020 Samsung Electronics Co. Ltd.
	*
	* 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 LOG_TAG "VendorGraphicBuffer"

	#include <log/log.h>
	#include <gralloctypes/Gralloc4.h>
	#include <android/hardware/graphics/mapper/4.0/IMapper.h>

	#include "VendorGraphicBuffer.h"
	#include "mali_gralloc_buffer.h"
	#include "mali_gralloc_formats.h"
	#include "hidl_common/SharedMetadata.h"
	#include "hidl_common/SharedMetadata_struct.h"
	#include "hidl_common/hidl_common.h"
	#include "exynos_format.h"

	#include <pixel-gralloc/metadata.h>
	#include <pixel-gralloc/mapper.h>

	using namespace android;
	using namespace vendor::graphics;

	using arm::mapper::common::shared_metadata;
	using aidl::android::hardware::graphics::common::Dataspace;
	using android::gralloc4::encodeDataspace;
	using android::gralloc4::decodeDataspace;
	using android::gralloc4::decodePixelFormatFourCC;
	using android::gralloc4::decodePixelFormatModifier;
	using android::hardware::graphics::mapper::V4_0::IMapper;
	using android::hardware::graphics::mapper::V4_0::Error;
	using MapperMetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;

	#define UNUSED(x) ((void)x)
	#define SZ_4k 0x1000

	// TODO(b/191912915): This is a non-thread safe version of the validate function
	// from mapper-4.0-impl library. Ideally this should be decoupled from `impl`
	// libraries and should depend upon HAL (and it's extension) to call into
	// Gralloc.
	int mali_gralloc_reference_validate(buffer_handle_t handle) {
	return private_handle_t::validate(handle);
	}

	const private_handle_t * convertNativeHandleToPrivateHandle(buffer_handle_t handle) {
	if (mali_gralloc_reference_validate(handle) < 0)
	return nullptr;

	return static_cast<const private_handle_t *>(handle);
	}

	android::sp<IMapper> get_mapper() {
	static android::sp<IMapper> mapper = []() {
	auto mapper = IMapper::getService();
	if (!mapper) {
	ALOGE("Failed to get mapper service");
	}
	return mapper;
	}();

	return mapper;
	}

	int VendorGraphicBufferMeta::get_video_metadata_fd(buffer_handle_t /hnd/)
	{
	ALOGE("%s function is obsolete and should not be used", __FUNCTION__);
	__builtin_trap();
	}

	int VendorGraphicBufferMeta::get_dataspace(buffer_handle_t hnd)
	{
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return -EINVAL;
	}

	Error error = Error::NONE;
	Dataspace dataspace;
	get_mapper()->get(handle, android::gralloc4::MetadataType_Dataspace,
	[&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}
	error = static_cast<Error>(decodeDataspace(tmpVec, &dataspace));
	});


	if (error != Error::NONE) {
	ALOGE("Failed to get datasapce");
	return -EINVAL;
	}

	return static_cast<int>(dataspace);
	}

	int VendorGraphicBufferMeta::set_dataspace(buffer_handle_t hnd, android_dataspace_t dataspace)
	{
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return -EINVAL;
	}

	Error error = Error::NONE;
	android::hardware::hidl_vec<uint8_t> vec;
	error = static_cast<Error>(encodeDataspace(static_cast<Dataspace>(dataspace), &vec));
	if (error != Error::NONE) {
	ALOGE("Error encoding dataspace");
	return -EINVAL;
	}
	error = get_mapper()->set(handle, android::gralloc4::MetadataType_Dataspace, vec);

	if (error != Error::NONE) {
	ALOGE("Failed to set datasapce");
	return -EINVAL;
	}

	return 0;
	}

	int VendorGraphicBufferMeta::is_afbc(buffer_handle_t hnd)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

	if (!gralloc_hnd)
	return 0;

	if (gralloc_hnd->alloc_format & MALI_GRALLOC_INTFMT_AFBCENABLE_MASK)
	return 1;

	return 0;
	}

	int VendorGraphicBufferMeta::is_sbwc(buffer_handle_t hnd)
	{
	return is_sbwc_format(VendorGraphicBufferMeta::get_internal_format(hnd));
	}

	#define GRALLOC_META_GETTER(__type__, __name__, __member__) \
	__type__ VendorGraphicBufferMeta::get_##__name__(buffer_handle_t hnd) \
	{ \
	const private_handle_t gralloc_hnd = static_cast<const private_handle_t >(hnd); \
	if (!gralloc_hnd) return 0; \
	return gralloc_hnd->__member__; \
	} \


	uint32_t VendorGraphicBufferMeta::get_format(buffer_handle_t hnd)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

	if (!gralloc_hnd)
	return 0;

	return static_cast<uint32_t>(gralloc_hnd->alloc_format);
	}

	uint64_t VendorGraphicBufferMeta::get_internal_format(buffer_handle_t hnd)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);;

	if (!gralloc_hnd)
	return 0;

	return static_cast<uint64_t>(gralloc_hnd->alloc_format & MALI_GRALLOC_INTFMT_FMT_MASK);
	}

	GRALLOC_META_GETTER(uint64_t, frameworkFormat, req_format);

	GRALLOC_META_GETTER(int, width, width);
	GRALLOC_META_GETTER(int, height, height);
	GRALLOC_META_GETTER(uint32_t, stride, stride);
	GRALLOC_META_GETTER(uint32_t, stride_in_bytes, plane_info[0].byte_stride);
	GRALLOC_META_GETTER(uint32_t, vstride, plane_info[0].alloc_height);

	GRALLOC_META_GETTER(uint64_t, producer_usage, producer_usage);
	GRALLOC_META_GETTER(uint64_t, consumer_usage, consumer_usage);

	GRALLOC_META_GETTER(uint64_t, flags, flags);


	int VendorGraphicBufferMeta::get_fd(buffer_handle_t hnd, int num)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

	if (!gralloc_hnd)
	return -1;

	if (num > 2)
	return -1;

	return gralloc_hnd->fds[num];
	}

	int VendorGraphicBufferMeta::get_size(buffer_handle_t hnd, int num)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

	if (!gralloc_hnd)
	return 0;

	if (num > 2)
	return 0;

	return gralloc_hnd->alloc_sizes[num];
	}


	uint64_t VendorGraphicBufferMeta::get_usage(buffer_handle_t hnd)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(hnd);

	if (!gralloc_hnd)
	return 0;

	return gralloc_hnd->producer_usage \| gralloc_hnd->consumer_usage;
	}

	void* decodePointer(const android::hardware::hidl_vec<uint8_t>& tmpVec) {
	constexpr uint8_t kPtrSize = sizeof(void*);
	assert(tmpVec.size() == kPtrSize);

	void* data_ptr;
	std::memcpy(&data_ptr, tmpVec.data(), kPtrSize);

	return data_ptr;
	}

	void* VendorGraphicBufferMeta::get_video_metadata(buffer_handle_t hnd)
	{
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return nullptr;
	}

	using namespace ::pixel::graphics;
	auto out_oe = mapper::get<MetadataType::VIDEO_HDR>(handle);

	if (!out_oe.has_value()) {
	ALOGE("Failed to get video HDR metadata");
	return nullptr;
	}

	return out_oe.value();
	}

	void* VendorGraphicBufferMeta::get_video_metadata_roiinfo(buffer_handle_t hnd)
	{
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return nullptr;
	}

	using namespace ::pixel::graphics;
	auto out_oe = mapper::get<MetadataType::VIDEO_ROI>(handle);

	if (!out_oe.has_value()) {
	ALOGE("Failed to get video ROI metadata");
	return nullptr;
	}

	return out_oe.value();
	}

	uint32_t VendorGraphicBufferMeta::get_format_fourcc(buffer_handle_t hnd) {
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return DRM_FORMAT_INVALID;
	}

	Error error = Error::NONE;
	uint32_t fourcc;
	get_mapper()->get(handle, android::gralloc4::MetadataType_PixelFormatFourCC,
	[&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}
	error = static_cast<Error>(decodePixelFormatFourCC(tmpVec, &fourcc));
	});


	if (error != Error::NONE) {
	ALOGE("Failed to get fourcc");
	return DRM_FORMAT_INVALID;
	}

	return fourcc;
	}

	uint64_t VendorGraphicBufferMeta::get_format_modifier(buffer_handle_t hnd) {
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return DRM_FORMAT_MOD_INVALID;
	}

	Error error = Error::NONE;
	uint64_t modifier;
	get_mapper()->get(handle, android::gralloc4::MetadataType_PixelFormatModifier,
	[&](const auto& tmpError, const android::hardware::hidl_vec<uint8_t>& tmpVec) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}
	error = static_cast<Error>(decodePixelFormatModifier(tmpVec, &modifier));
	});


	if (error != Error::NONE) {
	ALOGE("Failed to get format modifier");
	return DRM_FORMAT_MOD_INVALID;
	}

	return modifier;
	}

	void VendorGraphicBufferMeta::init(const buffer_handle_t handle)
	{
	const auto *gralloc_hnd = convertNativeHandleToPrivateHandle(handle);

	if (!gralloc_hnd)
	return;

	fd = gralloc_hnd->fds[0];
	fd1 = gralloc_hnd->fds[1];
	fd2 = gralloc_hnd->fds[2];

	size = gralloc_hnd->alloc_sizes[0];
	size1 = gralloc_hnd->alloc_sizes[1];
	size2 = gralloc_hnd->alloc_sizes[2];

	offsets[0] = gralloc_hnd->plane_info[0].offset;
	offsets[1] = gralloc_hnd->plane_info[1].offset;
	offsets[2] = gralloc_hnd->plane_info[2].offset;

	uint64_t usage = gralloc_hnd->producer_usage \| gralloc_hnd->consumer_usage;
	if (usage & VendorGraphicBufferUsage::VIDEO_PRIVATE_DATA) {
	switch (gralloc_hnd->get_share_attr_fd_index()) {
	case 1:
	size1 = gralloc_hnd->attr_size;
	break;
	case 2:
	size2 = gralloc_hnd->attr_size;
	break;
	}
	}

	internal_format = gralloc_hnd->alloc_format;
	frameworkFormat = gralloc_hnd->req_format;

	width = gralloc_hnd->width;
	height = gralloc_hnd->height;
	stride = gralloc_hnd->stride;
	vstride = gralloc_hnd->plane_info[0].alloc_height;

	producer_usage = gralloc_hnd->producer_usage;
	consumer_usage = gralloc_hnd->consumer_usage;

	flags = gralloc_hnd->flags;

	unique_id = gralloc_hnd->backing_store_id;
	}

	buffer_handle_t VendorGraphicBufferMeta::import_buffer(buffer_handle_t hnd)
	{
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return nullptr;
	}

	native_handle_t* bufferHandle = nullptr;
	Error error = Error::NONE;
	get_mapper()->importBuffer(handle, [&](const auto& tmpError, const auto& tmpBuffer) {
	error = tmpError;
	if (error != Error::NONE) {
	return;
	}
	bufferHandle = static_cast<native_handle_t*>(tmpBuffer);
	});

	if (error != Error::NONE) {
	ALOGE("[%s] Unable to import buffer", __FUNCTION__);
	return nullptr;
	}

	return bufferHandle;
	}

	int VendorGraphicBufferMeta::free_buffer(buffer_handle_t hnd)
	{
	native_handle_t* handle = const_cast<native_handle_t*>(hnd);
	if (!handle) {
	return -EINVAL;
	}
	Error error = get_mapper()->freeBuffer(handle);
	if (error != Error::NONE) {
	ALOGE("[%s] Failed to free buffer", __FUNCTION__);
	return -EINVAL;
	}
	return 0;
	}

	VendorGraphicBufferMeta::VendorGraphicBufferMeta(buffer_handle_t handle)
	{
	init(handle);
	}