/*
 * Copyright 2016 The Chromium OS Authors. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

/*
 * Please run clang-format on this file after making changes:
 *
 * clang-format -style=file -i gralloctest.c
 *
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <cutils/native_handle.h>
#include <hardware/gralloc.h>
#include <sync/sync.h>
#include <system/graphics.h>

#define ALIGN(A, B) (((A) + (B)-1) / (B) * (B))
#define ARRAY_SIZE(A) (sizeof(A) / sizeof(*(A)))

#define CHECK(cond)                                                                                \
	do {                                                                                       \
		if (!(cond)) {                                                                     \
			fprintf(stderr, "[  FAILED  ] check in %s() %s:%d\n", __func__, __FILE__,  \
				__LINE__);                                                         \
			return 0;                                                                  \
		}                                                                                  \
	} while (0)

#define CHECK_NO_MSG(cond)                                                                         \
	do {                                                                                       \
		if (!(cond)) {                                                                     \
			return 0;                                                                  \
		}                                                                                  \
	} while (0)

/* Private API enumeration -- see <gralloc_drm.h> */
enum { GRALLOC_DRM_GET_STRIDE,
       GRALLOC_DRM_GET_FORMAT,
       GRALLOC_DRM_GET_DIMENSIONS,
       GRALLOC_DRM_GET_BACKING_STORE,
};

struct gralloctest_context {
	struct gralloc_module_t *module;
	struct alloc_device_t *device;
	int api;
};

struct gralloc_testcase {
	const char *name;
	int (*run_test)(struct gralloctest_context *ctx);
	int required_api;
};

struct combinations {
	int32_t format;
	int32_t usage;
};

// clang-format off
static struct combinations combos[] = {
	{ HAL_PIXEL_FORMAT_RGBA_8888,
	  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN |
	  GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_COMPOSER |
	  GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_CURSOR },
	{ HAL_PIXEL_FORMAT_RGBA_8888,
	  GRALLOC_USAGE_HW_FB | GRALLOC_USAGE_HW_RENDER |
	  GRALLOC_USAGE_HW_COMPOSER },
	{ HAL_PIXEL_FORMAT_RGBX_8888,
	  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN },
	{ HAL_PIXEL_FORMAT_YCbCr_420_888,
	  GRALLOC_USAGE_EXTERNAL_DISP | GRALLOC_USAGE_HW_COMPOSER |
	  GRALLOC_USAGE_HW_TEXTURE },
	{ HAL_PIXEL_FORMAT_YCbCr_420_888,
	  GRALLOC_USAGE_RENDERSCRIPT | GRALLOC_USAGE_SW_READ_OFTEN |
	  GRALLOC_USAGE_SW_WRITE_OFTEN },
	{ HAL_PIXEL_FORMAT_YV12,
	  GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_HW_COMPOSER |
	  GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP },
	{ HAL_PIXEL_FORMAT_RGB_565,
	  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN },
	{ HAL_PIXEL_FORMAT_BGRA_8888,
	  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN },
	{ HAL_PIXEL_FORMAT_BLOB,
	  GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN },
};
// clang-format on

struct grallocinfo {
	buffer_handle_t handle;     /* handle to the buffer */
	int w;			    /* width  of buffer */
	int h;			    /* height of buffer */
	int format;		    /* format of the buffer */
	int usage;		    /* bitfield indicating usage */
	int fence_fd;		    /* fence file descriptor */
	void *vaddr;		    /* buffer virtual memory address */
	int stride;		    /* stride in pixels */
	struct android_ycbcr ycbcr; /* sw access for yuv buffers */
};

/* This function is meant to initialize the test to commonly used defaults. */
void grallocinfo_init(struct grallocinfo *info, int w, int h, int format, int usage)
{
	info->w = w;
	info->h = h;
	info->format = format;
	info->usage = usage;
	info->fence_fd = -1;
	info->vaddr = NULL;
	info->ycbcr.y = NULL;
	info->ycbcr.cb = NULL;
	info->ycbcr.cr = NULL;
	info->stride = 0;
}

static native_handle_t *duplicate_buffer_handle(buffer_handle_t handle)
{
	native_handle_t *hnd = native_handle_create(handle->numFds, handle->numInts);

	if (hnd == NULL)
		return NULL;

	const int *old_data = handle->data;
	int *new_data = hnd->data;

	int i;
	for (i = 0; i < handle->numFds; i++) {
		*new_data = dup(*old_data);
		old_data++;
		new_data++;
	}

	memcpy(new_data, old_data, sizeof(int) * handle->numInts);

	return hnd;
}

/****************************************************************
 * Wrappers around gralloc_module_t and alloc_device_t functions.
 * GraphicBufferMapper/GraphicBufferAllocator could replace this
 * in theory.
 ***************************************************************/

static int allocate(struct alloc_device_t *device, struct grallocinfo *info)
{
	int ret;

	ret = device->alloc(device, info->w, info->h, info->format, info->usage, &info->handle,
			    &info->stride);

	CHECK_NO_MSG(ret == 0);
	CHECK_NO_MSG(info->handle->version > 0);
	CHECK_NO_MSG(info->handle->numInts >= 0);
	CHECK_NO_MSG(info->handle->numFds >= 0);
	CHECK_NO_MSG(info->stride >= 0);

	return 1;
}

static int deallocate(struct alloc_device_t *device, struct grallocinfo *info)
{
	int ret;
	ret = device->free(device, info->handle);
	CHECK(ret == 0);
	return 1;
}

static int register_buffer(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;
	ret = module->registerBuffer(module, info->handle);
	return (ret == 0);
}

static int unregister_buffer(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;
	ret = module->unregisterBuffer(module, info->handle);
	return (ret == 0);
}

static int lock(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;

	ret = module->lock(module, info->handle, info->usage, 0, 0, (info->w) / 2, (info->h) / 2,
			   &info->vaddr);

	return (ret == 0);
}

static int unlock(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;
	ret = module->unlock(module, info->handle);
	return (ret == 0);
}

static int lock_ycbcr(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;

	ret = module->lock_ycbcr(module, info->handle, info->usage, 0, 0, (info->w) / 2,
				 (info->h) / 2, &info->ycbcr);

	return (ret == 0);
}

static int lock_async(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;

	ret = module->lockAsync(module, info->handle, info->usage, 0, 0, (info->w) / 2,
				(info->h) / 2, &info->vaddr, info->fence_fd);

	return (ret == 0);
}

static int unlock_async(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;

	ret = module->unlockAsync(module, info->handle, &info->fence_fd);

	return (ret == 0);
}

static int lock_async_ycbcr(struct gralloc_module_t *module, struct grallocinfo *info)
{
	int ret;

	ret = module->lockAsync_ycbcr(module, info->handle, info->usage, 0, 0, (info->w) / 2,
				      (info->h) / 2, &info->ycbcr, info->fence_fd);

	return (ret == 0);
}

/**************************************************************
 * END WRAPPERS                                               *
 **************************************************************/

/* This function tests initialization of gralloc module and allocator. */
static struct gralloctest_context *test_init_gralloc()
{
	int err;
	hw_module_t const *hw_module;
	struct gralloctest_context *ctx = calloc(1, sizeof(*ctx));

	err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &hw_module);
	if (err)
		return NULL;

	gralloc_open(hw_module, &ctx->device);
	ctx->module = (gralloc_module_t *)hw_module;
	if (!ctx->module || !ctx->device)
		return NULL;

	switch (ctx->module->common.module_api_version) {
	case GRALLOC_MODULE_API_VERSION_0_3:
		ctx->api = 3;
		break;
	case GRALLOC_MODULE_API_VERSION_0_2:
		ctx->api = 2;
		break;
	default:
		ctx->api = 1;
	}

	return ctx;
}

static int test_close_gralloc(struct gralloctest_context *ctx)
{
	CHECK(gralloc_close(ctx->device) == 0);
	return 1;
}

/* This function tests allocation with varying buffer dimensions. */
static int test_alloc_varying_sizes(struct gralloctest_context *ctx)
{
	struct grallocinfo info;
	int i;

	grallocinfo_init(&info, 0, 0, HAL_PIXEL_FORMAT_BGRA_8888, GRALLOC_USAGE_SW_READ_OFTEN);

	for (i = 1; i < 1920; i++) {
		info.w = i;
		info.h = i;
		CHECK(allocate(ctx->device, &info));
		CHECK(deallocate(ctx->device, &info));
	}

	info.w = 1;
	for (i = 1; i < 1920; i++) {
		info.h = i;
		CHECK(allocate(ctx->device, &info));
		CHECK(deallocate(ctx->device, &info));
	}

	info.h = 1;
	for (i = 1; i < 1920; i++) {
		info.w = i;
		CHECK(allocate(ctx->device, &info));
		CHECK(deallocate(ctx->device, &info));
	}

	return 1;
}

/*
 * This function tests that we find at least one working format for each
 * combos which we consider important.
 */
static int test_alloc_combinations(struct gralloctest_context *ctx)
{
	int i;

	struct grallocinfo info;
	grallocinfo_init(&info, 512, 512, 0, 0);

	for (i = 0; i < ARRAY_SIZE(combos); i++) {
		info.format = combos[i].format;
		info.usage = combos[i].usage;
		CHECK(allocate(ctx->device, &info));
		CHECK(deallocate(ctx->device, &info));
	}

	return 1;
}

/*
 * This function tests the advertised API version.
 * Version_0_2 added (*lock_ycbcr)() method.
 * Version_0_3 added fence passing to/from lock/unlock.
 */
static int test_api(struct gralloctest_context *ctx)
{

	CHECK(ctx->module->registerBuffer);
	CHECK(ctx->module->unregisterBuffer);
	CHECK(ctx->module->lock);
	CHECK(ctx->module->unlock);

	switch (ctx->module->common.module_api_version) {
	case GRALLOC_MODULE_API_VERSION_0_3:
		CHECK(ctx->module->lock_ycbcr);
		CHECK(ctx->module->lockAsync);
		CHECK(ctx->module->unlockAsync);
		CHECK(ctx->module->lockAsync_ycbcr);
		break;
	case GRALLOC_MODULE_API_VERSION_0_2:
		CHECK(ctx->module->lock_ycbcr);
		CHECK(ctx->module->lockAsync == NULL);
		CHECK(ctx->module->unlockAsync == NULL);
		CHECK(ctx->module->lockAsync_ycbcr == NULL);
		break;
	case GRALLOC_MODULE_API_VERSION_0_1:
		CHECK(ctx->module->lockAsync == NULL);
		CHECK(ctx->module->unlockAsync == NULL);
		CHECK(ctx->module->lockAsync_ycbcr == NULL);
		CHECK(ctx->module->lock_ycbcr == NULL);
		break;
	default:
		return 0;
	}

	return 1;
}

/*
 * This function registers, unregisters, locks and unlocks the buffer in
 * various orders.
 */
static int test_gralloc_order(struct gralloctest_context *ctx)
{
	struct grallocinfo info, duplicate;

	grallocinfo_init(&info, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888, GRALLOC_USAGE_SW_READ_OFTEN);

	grallocinfo_init(&duplicate, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
			 GRALLOC_USAGE_SW_READ_OFTEN);

	CHECK(allocate(ctx->device, &info));

	/*
	 * Duplicate the buffer handle to simulate an additional reference
	 * in same process.
	 */
	native_handle_t *native_handle = duplicate_buffer_handle(info.handle);
	duplicate.handle = native_handle;

	CHECK(unregister_buffer(ctx->module, &duplicate) == 0);
	CHECK(register_buffer(ctx->module, &duplicate));

	CHECK(unlock(ctx->module, &duplicate) == 0);

	CHECK(lock(ctx->module, &duplicate));
	CHECK(duplicate.vaddr);
	CHECK(unlock(ctx->module, &duplicate));

	CHECK(unregister_buffer(ctx->module, &duplicate));

	CHECK(register_buffer(ctx->module, &duplicate));
	CHECK(unregister_buffer(ctx->module, &duplicate));
	CHECK(unregister_buffer(ctx->module, &duplicate) == 0);

	CHECK(register_buffer(ctx->module, &duplicate));
	CHECK(deallocate(ctx->device, &info));

	CHECK(lock(ctx->module, &duplicate));
	CHECK(lock(ctx->module, &duplicate));
	CHECK(unlock(ctx->module, &duplicate));
	CHECK(unlock(ctx->module, &duplicate));
	CHECK(unlock(ctx->module, &duplicate) == 0);
	CHECK(unregister_buffer(ctx->module, &duplicate));

	CHECK(native_handle_close(duplicate.handle) == 0);
	CHECK(native_handle_delete(native_handle) == 0);

	return 1;
}

/* This function tests CPU reads and writes. */
static int test_mapping(struct gralloctest_context *ctx)
{
	struct grallocinfo info;
	uint32_t *ptr = NULL;
	uint32_t magic_number = 0x000ABBA;

	grallocinfo_init(&info, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
			 GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN);

	CHECK(allocate(ctx->device, &info));
	CHECK(lock(ctx->module, &info));

	ptr = (uint32_t *)info.vaddr;
	CHECK(ptr);
	ptr[(info.w) / 2] = magic_number;

	CHECK(unlock(ctx->module, &info));
	info.vaddr = NULL;
	ptr = NULL;

	CHECK(lock(ctx->module, &info));
	ptr = (uint32_t *)info.vaddr;
	CHECK(ptr);
	CHECK(ptr[info.w / 2] == magic_number);

	CHECK(unlock(ctx->module, &info));
	CHECK(deallocate(ctx->device, &info));

	return 1;
}

/* This function tests the private API we use in ARC++ -- not part of official
 * gralloc. */
static int test_perform(struct gralloctest_context *ctx)
{
	int32_t format;
	uint64_t id1, id2;
	uint32_t stride, width, height;
	struct grallocinfo info, duplicate;
	struct gralloc_module_t *mod = ctx->module;

	grallocinfo_init(&info, 650, 408, HAL_PIXEL_FORMAT_BGRA_8888, GRALLOC_USAGE_SW_READ_OFTEN);

	CHECK(allocate(ctx->device, &info));

	CHECK(mod->perform(mod, GRALLOC_DRM_GET_STRIDE, info.handle, &stride) == 0);
	CHECK(stride == info.stride);

	CHECK(mod->perform(mod, GRALLOC_DRM_GET_FORMAT, info.handle, &format) == 0);
	CHECK(format == info.format);

	CHECK(mod->perform(mod, GRALLOC_DRM_GET_DIMENSIONS, info.handle, &width, &height) == 0);
	CHECK(width == info.w);
	CHECK(height == info.h);

	native_handle_t *native_handle = duplicate_buffer_handle(info.handle);
	duplicate.handle = native_handle;

	CHECK(mod->perform(mod, GRALLOC_DRM_GET_BACKING_STORE, duplicate.handle, &id2));
	CHECK(register_buffer(mod, &duplicate));

	CHECK(mod->perform(mod, GRALLOC_DRM_GET_BACKING_STORE, info.handle, &id1) == 0);
	CHECK(mod->perform(mod, GRALLOC_DRM_GET_BACKING_STORE, duplicate.handle, &id2) == 0);
	CHECK(id1 == id2);

	CHECK(unregister_buffer(mod, &duplicate));
	CHECK(deallocate(ctx->device, &info));

	return 1;
}

/* This function tests that only YUV buffers work with *lock_ycbcr. */
static int test_ycbcr(struct gralloctest_context *ctx)

{
	struct grallocinfo info;
	grallocinfo_init(&info, 512, 512, HAL_PIXEL_FORMAT_YCbCr_420_888,
			 GRALLOC_USAGE_SW_READ_OFTEN);

	CHECK(allocate(ctx->device, &info));

	CHECK(lock(ctx->module, &info) == 0);
	CHECK(lock_ycbcr(ctx->module, &info));
	CHECK(info.ycbcr.y);
	CHECK(info.ycbcr.cb);
	CHECK(info.ycbcr.cr);
	CHECK(unlock(ctx->module, &info));

	CHECK(deallocate(ctx->device, &info));

	info.format = HAL_PIXEL_FORMAT_BGRA_8888;
	CHECK(allocate(ctx->device, &info));

	CHECK(lock_ycbcr(ctx->module, &info) == 0);
	CHECK(lock(ctx->module, &info));
	CHECK(unlock(ctx->module, &info));

	CHECK(deallocate(ctx->device, &info));

	return 1;
}

/*
 * This function tests a method ARC++ uses to query YUV buffer
 * info -- not part of official gralloc API.  This is used in
 * Mali, Mesa, the ArcCodec and  wayland_service.
 */
static int test_yuv_info(struct gralloctest_context *ctx)
{
	struct grallocinfo info;
	uintptr_t y_size, c_stride, c_size, cr_offset, cb_offset;
	uint32_t width, height;
	width = height = 512;

	/* <system/graphics.h> defines YV12 as having:
	 * - an even width
	 * - an even height
	 * - a horizontal stride multiple of 16 pixels
	 * - a vertical stride equal to the height
	 *
	 *   y_size = stride * height.
	 *   c_stride = ALIGN(stride/2, 16).
	 *   c_size = c_stride * height/2.
	 *   size = y_size + c_size * 2.
	 *   cr_offset = y_size.
	 *   cb_offset = y_size + c_size.
	 */

	grallocinfo_init(&info, width, height, HAL_PIXEL_FORMAT_YV12, GRALLOC_USAGE_SW_READ_OFTEN);

	CHECK(allocate(ctx->device, &info));

	y_size = info.stride * height;
	c_stride = ALIGN(info.stride / 2, 16);
	c_size = c_stride * height / 2;
	cr_offset = y_size;
	cb_offset = y_size + c_size;

	info.usage = 0;

	/*
	 * Check if the (*lock_ycbcr) with usage of zero returns the
	 * offsets and strides of the YV12 buffer. This is unofficial
	 * behavior we are testing here.
	 */
	CHECK(lock_ycbcr(ctx->module, &info));

	CHECK(info.stride == info.ycbcr.ystride);
	CHECK(c_stride == info.ycbcr.cstride);
	CHECK(cr_offset == (uintptr_t)info.ycbcr.cr);
	CHECK(cb_offset == (uintptr_t)info.ycbcr.cb);

	CHECK(unlock(ctx->module, &info));

	CHECK(deallocate(ctx->device, &info));

	return 1;
}

/* This function tests asynchronous locking and unlocking of buffers. */
static int test_async(struct gralloctest_context *ctx)

{
	struct grallocinfo rgba_info, ycbcr_info;
	grallocinfo_init(&rgba_info, 512, 512, HAL_PIXEL_FORMAT_BGRA_8888,
			 GRALLOC_USAGE_SW_READ_OFTEN);
	grallocinfo_init(&ycbcr_info, 512, 512, HAL_PIXEL_FORMAT_YCbCr_420_888,
			 GRALLOC_USAGE_SW_READ_OFTEN);

	CHECK(allocate(ctx->device, &rgba_info));
	CHECK(allocate(ctx->device, &ycbcr_info));

	CHECK(lock_async(ctx->module, &rgba_info));
	CHECK(lock_async_ycbcr(ctx->module, &ycbcr_info));

	CHECK(rgba_info.vaddr);
	CHECK(ycbcr_info.ycbcr.y);
	CHECK(ycbcr_info.ycbcr.cb);
	CHECK(ycbcr_info.ycbcr.cr);

	/*
	 * Wait on the fence returned from unlock_async and check it doesn't
	 * return an error.
	 */
	CHECK(unlock_async(ctx->module, &rgba_info));
	CHECK(unlock_async(ctx->module, &ycbcr_info));

	if (rgba_info.fence_fd >= 0) {
		CHECK(sync_wait(rgba_info.fence_fd, 10000) >= 0);
		CHECK(close(rgba_info.fence_fd) == 0);
	}

	if (ycbcr_info.fence_fd >= 0) {
		CHECK(sync_wait(ycbcr_info.fence_fd, 10000) >= 0);
		CHECK(close(ycbcr_info.fence_fd) == 0);
	}

	CHECK(deallocate(ctx->device, &rgba_info));
	CHECK(deallocate(ctx->device, &ycbcr_info));

	return 1;
}

static const struct gralloc_testcase tests[] = {
	{ "alloc_varying_sizes", test_alloc_varying_sizes, 1 },
	{ "alloc_combinations", test_alloc_combinations, 1 },
	{ "api", test_api, 1 },
	{ "gralloc_order", test_gralloc_order, 1 },
	{ "mapping", test_mapping, 1 },
	{ "perform", test_perform, 1 },
	{ "ycbcr", test_ycbcr, 2 },
	{ "yuv_info", test_yuv_info, 2 },
	{ "async", test_async, 3 },
};

static void print_help(const char *argv0)
{
	uint32_t i;
	printf("usage: %s <test_name>\n\n", argv0);
	printf("A valid name test is one the following:\n");
	for (i = 0; i < ARRAY_SIZE(tests); i++)
		printf("%s\n", tests[i].name);
}

int main(int argc, char *argv[])
{
	int ret = 0;
	uint32_t num_run = 0;

	setbuf(stdout, NULL);
	if (argc == 2) {
		uint32_t i;
		char *name = argv[1];

		struct gralloctest_context *ctx = test_init_gralloc();
		if (!ctx) {
			fprintf(stderr, "[  FAILED  ] to initialize gralloc.\n");
			return 1;
		}

		for (i = 0; i < ARRAY_SIZE(tests); i++) {
			if (strcmp(tests[i].name, name) && strcmp("all", name))
				continue;

			int success = 1;
			if (ctx->api >= tests[i].required_api)
				success = tests[i].run_test(ctx);

			printf("[ RUN      ] gralloctest.%s\n", tests[i].name);
			if (!success) {
				fprintf(stderr, "[  FAILED  ] gralloctest.%s\n", tests[i].name);
				ret |= 1;
			} else {
				printf("[  PASSED  ] gralloctest.%s\n", tests[i].name);
			}

			num_run++;
		}

		if (!test_close_gralloc(ctx)) {
			fprintf(stderr, "[  FAILED  ] to close gralloc.\n");
			return 1;
		}

		if (!num_run)
			goto print_usage;

		return ret;
	}

print_usage:
	print_help(argv[0]);
	return 0;
}