/*
 * Copyright (C) 2020 ARM Limited. All rights reserved.
 *
 * Copyright 2016 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.
 */

#include <inttypes.h>
#include <sync/sync.h>
#include <hardware/gralloc1.h>
#include "RegisteredHandlePool.h"
#include "Mapper.h"
#include "BufferDescriptor.h"
#include "mali_gralloc_log.h"
#include "core/mali_gralloc_bufferallocation.h"
#include "core/mali_gralloc_bufferdescriptor.h"
#include "core/mali_gralloc_bufferaccess.h"
#include "core/mali_gralloc_reference.h"
#include "core/format_info.h"
#include "allocator/mali_gralloc_ion.h"
#include "mali_gralloc_buffer.h"
#include "mali_gralloc_log.h"

#include "MapperMetadata.h"
#include "SharedMetadata.h"

#include <cstdio>

/* GraphicBufferMapper is expected to be valid (and leaked) during process
 * termination. IMapper, and in turn, gRegisteredHandles must be valid as
 * well. Create the registered handle pool on the heap, and let
 * it leak for simplicity.
 *
 * However, there is no way to make sure gralloc0/gralloc1 are valid. Any use
 * of static/global object in gralloc0/gralloc1 that may have been destructed
 * is potentially broken.
 */
RegisteredHandlePool* gRegisteredHandles = new RegisteredHandlePool;

namespace arm {
namespace mapper {
namespace common {

buffer_handle_t getBuffer(void *buffer) {
	return gRegisteredHandles->get(buffer);
}

/*
 * Translates the register buffer API into existing gralloc implementation
 *
 * @param bufferHandle [in] Private handle for the buffer to be imported
 *
 * @return Error::BAD_BUFFER for an invalid buffer
 *         Error::NO_RESOURCES when unable to import the given buffer
 *         Error::NONE on successful import
 */
static Error registerBuffer(buffer_handle_t bufferHandle)
{
	if (private_handle_t::validate(bufferHandle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is corrupted", bufferHandle);
		return Error::BAD_BUFFER;
	}

	if (mali_gralloc_reference_retain(bufferHandle) < 0)
	{
		return Error::NO_RESOURCES;
	}

	return Error::NONE;
}

/*
 * Translates the unregister buffer API into existing gralloc implementation
 *
 * @param bufferHandle [in] Private handle for the buffer to be released
 *
 * @return Error::BAD_BUFFER for an invalid buffer / buffers which can't be released
 *         Error::NONE on successful release of the buffer
 */
static Error unregisterBuffer(buffer_handle_t bufferHandle)
{
	if (private_handle_t::validate(bufferHandle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is corrupted", bufferHandle);
		return Error::BAD_BUFFER;
	}

	const int status = mali_gralloc_reference_release(bufferHandle);
	if (status != 0)
	{
		MALI_GRALLOC_LOGE("Unable to release buffer:%p", bufferHandle);
		return Error::BAD_BUFFER;
	}

	return Error::NONE;
}

/*
 * Converts a gralloc error code to a mapper error code
 *
 * @param grallocError  [in] Gralloc error as integer.
 *
 * @return Corresponding Mapper error code
 *
 * @note There is no full 1:1 correspondence, several gralloc errors may map to Error::UNSUPPORTED.
 * @note -EINVAL is mapped to Error::BAD_VALUE.
 */
static Error grallocErrorToMapperError(int grallocError)
{
	switch(grallocError)
	{
		case GRALLOC1_ERROR_NONE:
			return Error::NONE;
		case GRALLOC1_ERROR_BAD_DESCRIPTOR:
			return Error::BAD_DESCRIPTOR;
		case GRALLOC1_ERROR_BAD_HANDLE:
			return Error::BAD_BUFFER;
		case GRALLOC1_ERROR_BAD_VALUE:
		case -EINVAL:
			return Error::BAD_VALUE;
		case GRALLOC1_ERROR_NO_RESOURCES:
			return Error::NO_RESOURCES;
		default:
			/* Covers NOT_SHARED, UNDEFINED, UNSUPPORTED */
			return Error::UNSUPPORTED;
	}
}

/*
 * Locks the given buffer for the specified CPU usage.
 *
 * @param bufferHandle [in]  Buffer to lock.
 * @param cpuUsage     [in]  Specifies one or more CPU usage flags to request
 * @param accessRegion [in]  Portion of the buffer that the client intends to
 * access.
 * @param fenceFd      [in]  Fence file descriptor
 * @param outData      [out] CPU accessible buffer address
 *
 * @return Error::BAD_BUFFER for an invalid buffer
 *         Error::NO_RESOURCES when unable to duplicate fence
 *         Error::BAD_VALUE when locking fails
 *         Error::UNSUPPORTED when locking fails on unsupported image formats
 *         Error::NONE on successful buffer lock
 */
static Error lockBuffer(buffer_handle_t bufferHandle,
                        uint64_t cpuUsage,
                        const GrallocRect& accessRegion, int fenceFd,
                        void** outData)
{
	/* dup fenceFd as it is going to be owned by gralloc. Note that it is
	 * gralloc's responsibility to close it, even on locking errors.
	 */
	if (fenceFd >= 0)
	{
		fenceFd = dup(fenceFd);
		if (fenceFd < 0)
		{
			MALI_GRALLOC_LOGE("Error encountered while duplicating fence file descriptor");
			return Error::NO_RESOURCES;
		}
	}

	if (private_handle_t::validate(bufferHandle) < 0)
	{
		if (fenceFd >= 0)
		{
			close(fenceFd);
		}
		MALI_GRALLOC_LOGE("Buffer: %p is corrupted", bufferHandle);
		return Error::BAD_BUFFER;
	}

	if (mali_gralloc_reference_validate(bufferHandle) < 0)
	{
		if (fenceFd >= 0)
		{
			close(fenceFd);
		}
		MALI_GRALLOC_LOGE("Buffer: %p is not imported", bufferHandle);
		return Error::BAD_VALUE;
	}

	auto private_handle = private_handle_t::dynamicCast(bufferHandle);
	if (private_handle->cpu_write != 0 && (cpuUsage & static_cast<uint64_t>(BufferUsage::CPU_WRITE_MASK)))
	{
		if (fenceFd >= 0)
		{
			close(fenceFd);
		}
#if 0
		MALI_GRALLOC_LOGW("Attempt to call lock*() for writing on an already locked buffer (%p)", bufferHandle);
#endif

		/* TODO: handle simulatneous locks differently. May be keep a global lock count per buffer? */
	}
	else if (fenceFd >= 0)
	{
		sync_wait(fenceFd, -1);
		close(fenceFd);
	}

	void* data = nullptr;
	const int gralloc_err =
		mali_gralloc_lock(bufferHandle, cpuUsage, accessRegion.left, accessRegion.top,
				  accessRegion.right - accessRegion.left,
				  accessRegion.bottom - accessRegion.top, &data);
	const Error lock_err = grallocErrorToMapperError(gralloc_err);

	if(Error::NONE == lock_err)
	{
		*outData = data;
	}
	else
	{
		MALI_GRALLOC_LOGE("Locking failed with error: %d", gralloc_err);
	}

	return lock_err;
}

/*
 * Unlocks a buffer to indicate all CPU accesses to the buffer have completed
 *
 * @param bufferHandle [in]  Buffer to lock.
 * @param outFenceFd   [out] Fence file descriptor
 *
 * @return Error::BAD_BUFFER for an invalid buffer
 *         Error::BAD_VALUE when unlocking failed
 *         Error::NONE on successful buffer unlock
 */
static Error unlockBuffer(buffer_handle_t bufferHandle,
                                  int* outFenceFd)
{
	if (private_handle_t::validate(bufferHandle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is corrupted", bufferHandle);
		return Error::BAD_BUFFER;
	}

	const int gralloc_err = mali_gralloc_unlock(bufferHandle);
	const Error unlock_err = grallocErrorToMapperError(gralloc_err);

	if (Error::NONE == unlock_err)
	{
		*outFenceFd = -1;
	}
	else
	{
		MALI_GRALLOC_LOGE("Unlocking failed with error: %d",
				  gralloc_err);
		return Error::BAD_BUFFER;
	}

	return unlock_err;
}

Error importBuffer(const native_handle_t *inBuffer, buffer_handle_t *outBuffer)
{
	*outBuffer = const_cast<buffer_handle_t>(native_handle_clone(inBuffer));
	const Error error = registerBuffer(*outBuffer);
	if (error != Error::NONE)
	{
		return error;
	}

	if (gRegisteredHandles->add(*outBuffer) == false)
	{
		/* The newly cloned handle is already registered. This can only happen
		 * when a handle previously registered was native_handle_delete'd instead
		 * of freeBuffer'd.
		 */
		MALI_GRALLOC_LOGE("Handle %p has already been imported; potential fd leaking",
		       outBuffer);
		unregisterBuffer(*outBuffer);
		return Error::NO_RESOURCES;
	}

	return Error::NONE;
}

Error freeBuffer(buffer_handle_t bufferHandle)
{
	native_handle_t *handle = gRegisteredHandles->remove(bufferHandle);
	if (handle == nullptr)
	{
		MALI_GRALLOC_LOGE("Invalid buffer handle %p to freeBuffer", bufferHandle);
		return Error::BAD_BUFFER;
	}

	const Error status = unregisterBuffer(handle);
	if (status != Error::NONE)
	{
		return status;
	}

	native_handle_close(handle);
	native_handle_delete(handle);

	return Error::NONE;
}

Error lock(buffer_handle_t bufferHandle, uint64_t cpuUsage, const GrallocRect &accessRegion, int acquireFence, void **outData)
{
	*outData = nullptr;
	if (!bufferHandle || private_handle_t::validate(bufferHandle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer to lock: %p is not valid",
				  bufferHandle);
		return Error::BAD_BUFFER;
	}

	const Error error = lockBuffer(bufferHandle, cpuUsage, accessRegion,
				       acquireFence, outData);
	return error;
}

Error unlock(buffer_handle_t bufferHandle, int *releaseFence) {
	if(bufferHandle == nullptr) return Error::BAD_BUFFER;
	if(!gRegisteredHandles->isRegistered(bufferHandle)) {
		MALI_GRALLOC_LOGE("Buffer to unlock: %p has not been registered with Gralloc",
		    bufferHandle);
		return Error::BAD_BUFFER;
	}

	const Error error = unlockBuffer(bufferHandle, releaseFence);
	return error;
}
#ifdef GRALLOC_MAPPER_4
Error validateBufferSize(void* buffer,
                         const IMapper::BufferDescriptorInfo& descriptorInfo,
                         uint32_t in_stride)
{
	/* The buffer must have been allocated by Gralloc */
	buffer_handle_t bufferHandle = gRegisteredHandles->get(buffer);
	if (!bufferHandle)
	{
		MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
		return Error::BAD_BUFFER;
	}

	if (private_handle_t::validate(bufferHandle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is corrupted", bufferHandle);
		return Error::BAD_BUFFER;
	}

	buffer_descriptor_t grallocDescriptor;
	grallocDescriptor.width = descriptorInfo.width;
	grallocDescriptor.height = descriptorInfo.height;
	grallocDescriptor.layer_count = descriptorInfo.layerCount;
	grallocDescriptor.hal_format = static_cast<uint64_t>(descriptorInfo.format);
	grallocDescriptor.producer_usage = static_cast<uint64_t>(descriptorInfo.usage);
	grallocDescriptor.consumer_usage = grallocDescriptor.producer_usage;
	grallocDescriptor.format_type = MALI_GRALLOC_FORMAT_TYPE_USAGE;

	/* Derive the buffer size for the given descriptor */
	const int result = mali_gralloc_derive_format_and_size(&grallocDescriptor);
	if (result)
	{
		MALI_GRALLOC_LOGV("Unable to derive format and size for the given descriptor information. error: %d", result);
		return Error::BAD_VALUE;
	}

	/* Validate the buffer parameters against descriptor info */
	private_handle_t *gralloc_buffer = (private_handle_t *)bufferHandle;

	/* The buffer size must be greater than (or equal to) what would have been allocated with descriptor */
	for (int i = 0; i < gralloc_buffer->fd_count; i++)
	{
		if (gralloc_buffer->alloc_sizes[i] < grallocDescriptor.alloc_sizes[i])
		{
			MALI_GRALLOC_LOGW("Buf size mismatch. fd_idx(%d) Buffer size = %" PRIu64 ", Descriptor (derived) size = %" PRIu64,
			       i, gralloc_buffer->alloc_sizes[i], grallocDescriptor.alloc_sizes[i]);
			return Error::BAD_VALUE;
		}
	}

	if (in_stride != 0 && (uint32_t)gralloc_buffer->stride != in_stride)
	{
		MALI_GRALLOC_LOGE("Stride mismatch. Expected stride = %d, Buffer stride = %" PRIu64,
		                       in_stride, gralloc_buffer->stride);
		return Error::BAD_VALUE;
	}

	if (gralloc_buffer->alloc_format != grallocDescriptor.alloc_format)
	{
		MALI_GRALLOC_LOGE("Buffer alloc format: (%s, 0x%" PRIx64") does not match descriptor (derived) alloc format: (%s 0x%"
			PRIx64 ")", format_name(gralloc_buffer->alloc_format), gralloc_buffer->alloc_format,
			format_name(grallocDescriptor.alloc_format), grallocDescriptor.alloc_format);
		return Error::BAD_VALUE;
	}

	const int format_idx = get_format_index(gralloc_buffer->alloc_format & MALI_GRALLOC_INTFMT_FMT_MASK);
	if (format_idx == -1)
	{
		MALI_GRALLOC_LOGE("Invalid format to validate buffer descriptor");
		return Error::BAD_VALUE;
	}
	else
	{
		for (int i = 0; i < formats[format_idx].npln; i++)
		{
			if (gralloc_buffer->plane_info[i].byte_stride != grallocDescriptor.plane_info[i].byte_stride)
			{
				MALI_GRALLOC_LOGE("Buffer byte stride %" PRIu64 " mismatch with desc byte stride %" PRIu64 " in plane %d ",
				      gralloc_buffer->plane_info[i].byte_stride, grallocDescriptor.plane_info[i].byte_stride, i);
				return Error::BAD_VALUE;
			}

			if (gralloc_buffer->plane_info[i].alloc_width != grallocDescriptor.plane_info[i].alloc_width)
			{
				MALI_GRALLOC_LOGE("Buffer alloc width %" PRIu64 " mismatch with desc alloc width %" PRIu64 " in plane %d ",
				      gralloc_buffer->plane_info[i].alloc_width, grallocDescriptor.plane_info[i].alloc_width, i);
				return Error::BAD_VALUE;
			}

			if (gralloc_buffer->plane_info[i].alloc_height != grallocDescriptor.plane_info[i].alloc_height)
			{
				MALI_GRALLOC_LOGE("Buffer alloc height %" PRIu64 " mismatch with desc alloc height %" PRIu64 " in plane %d ",
				      gralloc_buffer->plane_info[i].alloc_height, grallocDescriptor.plane_info[i].alloc_height, i);
				return Error::BAD_VALUE;
			}
		}
	}

	if ((uint32_t)gralloc_buffer->width != grallocDescriptor.width)
	{
		MALI_GRALLOC_LOGE("Width mismatch. Buffer width = %u, Descriptor width = %u",
		      gralloc_buffer->width, grallocDescriptor.width);
		return Error::BAD_VALUE;
	}

	if ((uint32_t)gralloc_buffer->height != grallocDescriptor.height)
	{
		MALI_GRALLOC_LOGE("Height mismatch. Buffer height = %u, Descriptor height = %u",
		      gralloc_buffer->height, grallocDescriptor.height);
		return Error::BAD_VALUE;
	}

	if (gralloc_buffer->layer_count != grallocDescriptor.layer_count)
	{
		MALI_GRALLOC_LOGE("Layer Count mismatch. Buffer layer_count = %u, Descriptor layer_count width = %u",
		      gralloc_buffer->layer_count, grallocDescriptor.layer_count);
		return Error::BAD_VALUE;
	}

	return Error::NONE;
}
#endif

Error getTransportSize(buffer_handle_t bufferHandle, uint32_t *outNumFds, uint32_t *outNumInts)
{
	*outNumFds = 0;
	*outNumInts = 0;
	/* The buffer must have been allocated by Gralloc */
	if (!bufferHandle)
	{
		MALI_GRALLOC_LOGE("Buffer %p is not registered with Gralloc",
				  bufferHandle);
		return Error::BAD_BUFFER;
	}

	if (private_handle_t::validate(bufferHandle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer %p is corrupted", bufferHandle);
		return Error::BAD_BUFFER;
	}
	*outNumFds = bufferHandle->numFds;
	*outNumInts = bufferHandle->numInts;
	return Error::NONE;
}

#ifdef GRALLOC_MAPPER_4
bool isSupported(const IMapper::BufferDescriptorInfo &description)
{
	buffer_descriptor_t grallocDescriptor;
	grallocDescriptor.width = description.width;
	grallocDescriptor.height = description.height;
	grallocDescriptor.layer_count = description.layerCount;
	grallocDescriptor.hal_format = static_cast<uint64_t>(description.format);
	grallocDescriptor.producer_usage = static_cast<uint64_t>(description.usage);
	grallocDescriptor.consumer_usage = grallocDescriptor.producer_usage;
	grallocDescriptor.format_type = MALI_GRALLOC_FORMAT_TYPE_USAGE;

	/* Check if it is possible to allocate a buffer for the given description */
	const int result = mali_gralloc_derive_format_and_size(&grallocDescriptor);
	if (result != 0)
	{
		MALI_GRALLOC_LOGV("Allocation for the given description will not succeed. error: %d", result);
		return false;
	}
	else
	{
		return true;
	}
}

#endif
Error flushLockedBuffer(buffer_handle_t handle)
{
	if (private_handle_t::validate(handle) < 0)
	{
		MALI_GRALLOC_LOGE("Handle: %p is corrupted", handle);
		return Error::BAD_BUFFER;
	}

	auto private_handle = static_cast<const private_handle_t *>(handle);
	if (!private_handle->cpu_write && !private_handle->cpu_read)
	{
		MALI_GRALLOC_LOGE("Attempt to call flushLockedBuffer() on an unlocked buffer (%p)", handle);
		return Error::BAD_BUFFER;
	}

	mali_gralloc_ion_sync_end(private_handle, false, true);
	return Error::NONE;
}

Error rereadLockedBuffer(buffer_handle_t handle)
{
	if (private_handle_t::validate(handle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is corrupted", handle);
		return Error::BAD_BUFFER;
	}

	auto private_handle = static_cast<const private_handle_t *>(handle);
	if (!private_handle->cpu_write && !private_handle->cpu_read)
	{
		MALI_GRALLOC_LOGE("Attempt to call rereadLockedBuffer() on an unlocked buffer (%p)", handle);
		return Error::BAD_BUFFER;
	}

	mali_gralloc_ion_sync_start(private_handle, true, false);
	return Error::NONE;
}

Error get(buffer_handle_t buffer, const MetadataType &metadataType, std::vector<uint8_t> &vec)
{
	/* The buffer must have been allocated by Gralloc */
	const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
	if (handle == nullptr)
	{
		MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
		return Error::BAD_BUFFER;
	}

	if (mali_gralloc_reference_validate((buffer_handle_t)handle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is not imported", handle);
		return Error::BAD_VALUE;
	}

	return get_metadata(handle, metadataType, vec);
}

Error set(buffer_handle_t buffer, const MetadataType &metadataType, const hidl_vec<uint8_t> &metadata)
{
	/* The buffer must have been allocated by Gralloc */
	const private_handle_t *handle = static_cast<const private_handle_t *>(buffer);
	if (handle == nullptr)
	{
		MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
		return Error::BAD_BUFFER;
	}

	if (mali_gralloc_reference_validate((buffer_handle_t)handle) < 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p is not imported", handle);
		return Error::BAD_VALUE;
	}

	return set_metadata(handle, metadataType, metadata);
}

MetadataTypeDescription describeStandard(StandardMetadataType meta, bool isGettable, bool isSettable)
{
	return MetadataTypeDescription(MetadataType(GRALLOC4_STANDARD_METADATA_TYPE,
						    static_cast<uint64_t>(meta)), "", isGettable, isSettable);
}

std::vector<MetadataTypeDescription> listSupportedMetadataTypes()
{
	/* Returns a vector of {metadata type, description, isGettable, isSettable}
	*  Only non-standardMetadataTypes require a description.
	*/
	std::array<MetadataTypeDescription, 23> descriptions = {
		describeStandard(StandardMetadataType::BUFFER_ID, true, false ),
		describeStandard(StandardMetadataType::NAME, true, false ),
		describeStandard(StandardMetadataType::WIDTH, true, false ),
		describeStandard(StandardMetadataType::STRIDE, true, false ),
		describeStandard(StandardMetadataType::HEIGHT, true, false ),
		describeStandard(StandardMetadataType::LAYER_COUNT, true, false ),
		describeStandard(StandardMetadataType::PIXEL_FORMAT_REQUESTED, true, false ),
		describeStandard(StandardMetadataType::PIXEL_FORMAT_FOURCC, true, false ),
		describeStandard(StandardMetadataType::PIXEL_FORMAT_MODIFIER, true, false ),
		describeStandard(StandardMetadataType::USAGE, true, false ),
		describeStandard(StandardMetadataType::ALLOCATION_SIZE, true, false ),
		describeStandard(StandardMetadataType::PROTECTED_CONTENT, true, false ),
		describeStandard(StandardMetadataType::COMPRESSION, true, false ),
		describeStandard(StandardMetadataType::INTERLACED, true, false ),
		describeStandard(StandardMetadataType::CHROMA_SITING, true, false ),
		describeStandard(StandardMetadataType::PLANE_LAYOUTS, true, false ),
		describeStandard(StandardMetadataType::DATASPACE, true, true ),
		describeStandard(StandardMetadataType::BLEND_MODE, true, true ),
		describeStandard(StandardMetadataType::SMPTE2086, true, true ),
		describeStandard(StandardMetadataType::CTA861_3, true, true ),
		describeStandard(StandardMetadataType::SMPTE2094_40, true, true ),
		describeStandard(StandardMetadataType::CROP, true, true ),
		/* Arm vendor metadata */
		{ ArmMetadataType_PLANE_FDS,
			"Vector of file descriptors of each plane", true, false},
        };
	return std::vector<MetadataTypeDescription>(descriptions.begin(), descriptions.end());
}


static BufferDump dumpBufferHelper(const private_handle_t *handle)
{
	static std::array<MetadataType, 21> standardMetadataTypes = {
		MetadataType(StandardMetadataType::BUFFER_ID),
		MetadataType(StandardMetadataType::NAME),
		MetadataType(StandardMetadataType::WIDTH),
		MetadataType(StandardMetadataType::HEIGHT),
		MetadataType(StandardMetadataType::LAYER_COUNT),
		MetadataType(StandardMetadataType::PIXEL_FORMAT_REQUESTED),
		MetadataType(StandardMetadataType::PIXEL_FORMAT_FOURCC),
		MetadataType(StandardMetadataType::PIXEL_FORMAT_MODIFIER),
		MetadataType(StandardMetadataType::USAGE),
		MetadataType(StandardMetadataType::ALLOCATION_SIZE),
		MetadataType(StandardMetadataType::PROTECTED_CONTENT),
		MetadataType(StandardMetadataType::COMPRESSION),
		MetadataType(StandardMetadataType::INTERLACED),
		MetadataType(StandardMetadataType::CHROMA_SITING),
		MetadataType(StandardMetadataType::PLANE_LAYOUTS),
		MetadataType(StandardMetadataType::DATASPACE),
		MetadataType(StandardMetadataType::BLEND_MODE),
		MetadataType(StandardMetadataType::SMPTE2086),
		MetadataType(StandardMetadataType::CTA861_3),
		MetadataType(StandardMetadataType::SMPTE2094_40),
		MetadataType(StandardMetadataType::CROP),
	};

	std::vector<MetadataDump> metadataDumps;
	for (const auto& metadataType: standardMetadataTypes)
	{
		std::vector<uint8_t> metadata;
		Error error = get_metadata(handle, metadataType, metadata);
		if (error == Error::NONE)
		{
			metadataDumps.push_back(MetadataDump(MetadataType(metadataType), metadata));
		}
		else
		{
			return BufferDump();
		}
	}
	return BufferDump(metadataDumps);
}

Error dumpBuffer(buffer_handle_t buffer, BufferDump &bufferDump)
{
	auto handle = static_cast<const private_handle_t *>(buffer);
	if (handle == nullptr)
	{
		MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
		return Error::BAD_BUFFER;
	}

	bufferDump = dumpBufferHelper(handle);
	return Error::NONE;
}

std::vector<BufferDump> dumpBuffers()
{
	std::vector<BufferDump> bufferDumps;
	gRegisteredHandles->for_each([&bufferDumps](buffer_handle_t buffer) {
		BufferDump bufferDump { dumpBufferHelper(static_cast<const private_handle_t *>(buffer)) };
		bufferDumps.push_back(bufferDump);
	});
	return bufferDumps;
}

Error getReservedRegion(buffer_handle_t buffer, void **outReservedRegion, uint64_t &outReservedSize)
{
	auto handle = static_cast<const private_handle_t *>(buffer);
	if (handle == nullptr)
	{
		MALI_GRALLOC_LOGE("Buffer: %p has not been registered with Gralloc", buffer);
		return Error::BAD_BUFFER;
	}
	else if (handle->reserved_region_size == 0)
	{
		MALI_GRALLOC_LOGE("Buffer: %p has no reserved region", buffer);
		return Error::BAD_BUFFER;
	}

	auto metadata_addr_oe = mali_gralloc_reference_get_metadata_addr(handle);
	if (!metadata_addr_oe.has_value()) {
		return Error::BAD_BUFFER;
	}

	*outReservedRegion = static_cast<std::byte *>(metadata_addr_oe.value())
	    + mapper::common::shared_metadata_size();
	outReservedSize = handle->reserved_region_size;
	return Error::NONE;
}

} // namespace common
} // namespace mapper
} // namespace arm