// SPDX-License-Identifier: GPL-2.0+

#include <kunit/test.h>

#include <drm/drm_fixed.h>
#include <drm/drm_mode.h>
#include "../vkms_composer.h"
#include "../vkms_drv.h"
#include "../vkms_luts.h"

#define TEST_LUT_SIZE 16

MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");

static struct drm_color_lut test_linear_array[TEST_LUT_SIZE] = {
	{ 0x0, 0x0, 0x0, 0 },
	{ 0x1111, 0x1111, 0x1111, 0 },
	{ 0x2222, 0x2222, 0x2222, 0 },
	{ 0x3333, 0x3333, 0x3333, 0 },
	{ 0x4444, 0x4444, 0x4444, 0 },
	{ 0x5555, 0x5555, 0x5555, 0 },
	{ 0x6666, 0x6666, 0x6666, 0 },
	{ 0x7777, 0x7777, 0x7777, 0 },
	{ 0x8888, 0x8888, 0x8888, 0 },
	{ 0x9999, 0x9999, 0x9999, 0 },
	{ 0xaaaa, 0xaaaa, 0xaaaa, 0 },
	{ 0xbbbb, 0xbbbb, 0xbbbb, 0 },
	{ 0xcccc, 0xcccc, 0xcccc, 0 },
	{ 0xdddd, 0xdddd, 0xdddd, 0 },
	{ 0xeeee, 0xeeee, 0xeeee, 0 },
	{ 0xffff, 0xffff, 0xffff, 0 },
};

/* lerp test parameters */
struct vkms_color_test_lerp_params {
	s64 t;
	__u16 a;
	__u16 b;
	__u16 expected;
};

/* lerp test cases */
static const struct vkms_color_test_lerp_params color_test_lerp_cases[] = {
	/* Half-way round down */
	{ 0x80000000 - 1, 0x0, 0x10, 0x8 },
	{ 0x80000000 - 1, 0x1, 0x10, 0x8 },	/* Odd a */
	{ 0x80000000 - 1, 0x1, 0xf, 0x8 },	/* Odd b */
	{ 0x80000000 - 1, 0x10, 0x10, 0x10 },	/* b = a */
	{ 0x80000000 - 1, 0x10, 0x11, 0x10 },	/* b = a + 1*/
	/* Half-way round up */
	{ 0x80000000, 0x0, 0x10, 0x8 },
	{ 0x80000000, 0x1, 0x10, 0x9 },		/* Odd a */
	{ 0x80000000, 0x1, 0xf, 0x8 },		/* Odd b */
	{ 0x80000000, 0x10, 0x10, 0x10 },	/* b = a */
	{ 0x80000000, 0x10, 0x11, 0x11 },	/* b = a + 1*/
	/*  t = 0.0 */
	{ 0x0, 0x0, 0x10, 0x0 },
	{ 0x0, 0x1, 0x10, 0x1 },		/* Odd a */
	{ 0x0, 0x1, 0xf, 0x1 },			/* Odd b */
	{ 0x0, 0x10, 0x10, 0x10 },		/* b = a */
	{ 0x0, 0x10, 0x11, 0x10 },		/* b = a + 1*/
	/*  t = 1.0 */
	{ 0x100000000, 0x0, 0x10, 0x10 },
	{ 0x100000000, 0x1, 0x10, 0x10 },	/* Odd a */
	{ 0x100000000, 0x1, 0xf, 0xf },		/* Odd b */
	{ 0x100000000, 0x10, 0x10, 0x10 },	/* b = a */
	{ 0x100000000, 0x10, 0x11, 0x11 },	/* b = a + 1*/
	/*  t = 0.0 + 1 */
	{ 0x0 + 1, 0x0, 0x10, 0x0 },
	{ 0x0 + 1, 0x1, 0x10, 0x1 },		/* Odd a */
	{ 0x0 + 1, 0x1, 0xf, 0x1 },		/* Odd b */
	{ 0x0 + 1, 0x10, 0x10, 0x10 },		/* b = a */
	{ 0x0 + 1, 0x10, 0x11, 0x10 },		/* b = a + 1*/
	/*  t = 1.0 - 1 */
	{ 0x100000000 - 1, 0x0, 0x10, 0x10 },
	{ 0x100000000 - 1, 0x1, 0x10, 0x10 },	/* Odd a */
	{ 0x100000000 - 1, 0x1, 0xf, 0xf },	/* Odd b */
	{ 0x100000000 - 1, 0x10, 0x10, 0x10 },	/* b = a */
	{ 0x100000000 - 1, 0x10, 0x11, 0x11 },	/* b = a + 1*/
	/*  t chosen to verify the flipping point of result a (or b) to a+1 (or b-1) */
	{ 0x80000000 - 1, 0x0, 0x1, 0x0 },
	{ 0x80000000, 0x0, 0x1, 0x1 },
};

static const struct vkms_color_lut test_linear_lut = {
	.base = test_linear_array,
	.lut_length = TEST_LUT_SIZE,
	.channel_value2index_ratio = 0xf000fll
};

static void vkms_color_test_get_lut_index(struct kunit *test)
{
	s64 lut_index;
	int i;

	lut_index = get_lut_index(&test_linear_lut, test_linear_array[0].red);
	KUNIT_EXPECT_EQ(test, drm_fixp2int(lut_index), 0);

	for (i = 0; i < TEST_LUT_SIZE; i++) {
		lut_index = get_lut_index(&test_linear_lut, test_linear_array[i].red);
		KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(lut_index), i);
	}

	KUNIT_EXPECT_EQ(test, drm_fixp2int(get_lut_index(&srgb_eotf, 0x0)), 0x0);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_eotf, 0x0)), 0x0);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_eotf, 0x101)), 0x1);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_eotf, 0x202)), 0x2);

	KUNIT_EXPECT_EQ(test, drm_fixp2int(get_lut_index(&srgb_inv_eotf, 0x0)), 0x0);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_inv_eotf, 0x0)), 0x0);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_inv_eotf, 0x101)), 0x1);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_inv_eotf, 0x202)), 0x2);

	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_eotf, 0xfefe)), 0xfe);
	KUNIT_EXPECT_EQ(test, drm_fixp2int_ceil(get_lut_index(&srgb_eotf, 0xffff)), 0xff);
}

static void vkms_color_test_lerp(struct kunit *test)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(color_test_lerp_cases); i++) {
		const struct vkms_color_test_lerp_params *params = &color_test_lerp_cases[i];

		KUNIT_EXPECT_EQ(test, lerp_u16(params->a, params->b, params->t), params->expected);
	}
}

static void vkms_color_test_linear(struct kunit *test)
{
	for (int i = 0; i < LUT_SIZE; i++) {
		int linear = apply_lut_to_channel_value(&linear_eotf, i * 0x101, LUT_RED);

		KUNIT_EXPECT_EQ(test, DIV_ROUND_CLOSEST(linear, 0x101), i);
	}
}

static void vkms_color_srgb_inv_srgb(struct kunit *test)
{
	u16 srgb, final;

	for (int i = 0; i < LUT_SIZE; i++) {
		srgb = apply_lut_to_channel_value(&srgb_eotf, i * 0x101, LUT_RED);
		final = apply_lut_to_channel_value(&srgb_inv_eotf, srgb, LUT_RED);

		KUNIT_EXPECT_GE(test, final / 0x101, i - 1);
		KUNIT_EXPECT_LE(test, final / 0x101, i + 1);
	}
}

#define FIXPT_HALF        (DRM_FIXED_ONE >> 1)
#define FIXPT_QUARTER     (DRM_FIXED_ONE >> 2)

static const struct drm_color_ctm_3x4 test_matrix_3x4_50_desat = { {
	FIXPT_HALF, FIXPT_QUARTER, FIXPT_QUARTER, 0,
	FIXPT_QUARTER, FIXPT_HALF, FIXPT_QUARTER, 0,
	FIXPT_QUARTER, FIXPT_QUARTER, FIXPT_HALF, 0
} };

static void vkms_color_ctm_3x4_50_desat(struct kunit *test)
{
	struct pixel_argb_s32 ref, out;

	/* full white */
	ref.a = 0xffff;
	ref.r = 0xffff;
	ref.g = 0xffff;
	ref.b = 0xffff;

	memcpy(&out, &ref, sizeof(out));
	apply_3x4_matrix(&out, &test_matrix_3x4_50_desat);

	KUNIT_EXPECT_MEMEQ(test, &ref, &out, sizeof(out));

	/* full black */
	ref.a = 0xffff;
	ref.r = 0x0;
	ref.g = 0x0;
	ref.b = 0x0;

	memcpy(&out, &ref, sizeof(out));
	apply_3x4_matrix(&out, &test_matrix_3x4_50_desat);

	KUNIT_EXPECT_MEMEQ(test, &ref, &out, sizeof(out));

	/* 50% grey */
	ref.a = 0xffff;
	ref.r = 0x8000;
	ref.g = 0x8000;
	ref.b = 0x8000;

	memcpy(&out, &ref, sizeof(out));
	apply_3x4_matrix(&out, &test_matrix_3x4_50_desat);

	KUNIT_EXPECT_MEMEQ(test, &ref, &out, sizeof(out));

	/* full red to 50% desat */
	ref.a = 0xffff;
	ref.r = 0x8000;
	ref.g = 0x4000;
	ref.b = 0x4000;

	out.a = 0xffff;
	out.r = 0xffff;
	out.g = 0x0;
	out.b = 0x0;

	apply_3x4_matrix(&out, &test_matrix_3x4_50_desat);

	KUNIT_EXPECT_MEMEQ(test, &ref, &out, sizeof(out));
}

/*
 * BT.709 encoding matrix
 *
 * Values printed from within IGT when converting
 * igt_matrix_3x4_bt709_enc to the fixed-point format expected
 * by DRM/KMS.
 */
static const struct drm_color_ctm_3x4 test_matrix_3x4_bt709_enc = { {
	0x00000000366cf400ull, 0x00000000b7175900ull, 0x0000000127bb300ull, 0,
	0x800000001993b3a0ull, 0x800000005609fe80ull, 0x000000006f9db200ull, 0,
	0x000000009d70a400ull, 0x800000008f011100ull, 0x800000000e6f9330ull, 0
} };

static void vkms_color_ctm_3x4_bt709(struct kunit *test)
{
	struct pixel_argb_s32 out;

	/* full white to bt709 */
	out.a = 0xffff;
	out.r = 0xffff;
	out.g = 0xffff;
	out.b = 0xffff;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 255 */
	KUNIT_EXPECT_GT(test, out.r, 0xfe00);
	KUNIT_EXPECT_LT(test, out.r, 0x10000);

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x0100);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x0100);

	/* full black to bt709 */
	out.a = 0xffff;
	out.r = 0x0;
	out.g = 0x0;
	out.b = 0x0;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 0 */
	KUNIT_EXPECT_LT(test, out.r, 0x100);

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x0100);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x0100);

	/* gray to bt709 */
	out.a = 0xffff;
	out.r = 0x7fff;
	out.g = 0x7fff;
	out.b = 0x7fff;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 127 */
	KUNIT_EXPECT_GT(test, out.r, 0x7e00);
	KUNIT_EXPECT_LT(test, out.r, 0x8000);

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x0100);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x0100);

	/* == red 255 - bt709 enc == */
	out.a = 0xffff;
	out.r = 0xffff;
	out.g = 0x0;
	out.b = 0x0;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 54 */
	KUNIT_EXPECT_GT(test, out.r, 0x3500);
	KUNIT_EXPECT_LT(test, out.r, 0x3700);

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x0100);

	/* V 157 */
	KUNIT_EXPECT_GT(test, out.b, 0x9C00);
	KUNIT_EXPECT_LT(test, out.b, 0x9E00);

	/* == green 255 - bt709 enc == */
	out.a = 0xffff;
	out.r = 0x0;
	out.g = 0xffff;
	out.b = 0x0;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 182 */
	KUNIT_EXPECT_GT(test, out.r, 0xB500);
	KUNIT_EXPECT_LT(test, out.r, 0xB780); /* laxed by half*/

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x0100);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x0100);

	/* == blue 255 - bt709 enc == */
	out.a = 0xffff;
	out.r = 0x0;
	out.g = 0x0;
	out.b = 0xffff;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 18 */
	KUNIT_EXPECT_GT(test, out.r, 0x1100);
	KUNIT_EXPECT_LT(test, out.r, 0x1300);

	/* U 111 */
	KUNIT_EXPECT_GT(test, out.g, 0x6E00);
	KUNIT_EXPECT_LT(test, out.g, 0x7000);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x0100);

	/* == red 140 - bt709 enc == */
	out.a = 0xffff;
	out.r = 0x8c8c;
	out.g = 0x0;
	out.b = 0x0;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 30 */
	KUNIT_EXPECT_GT(test, out.r, 0x1D00);
	KUNIT_EXPECT_LT(test, out.r, 0x1F00);

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x100);

	/* V 87 */
	KUNIT_EXPECT_GT(test, out.b, 0x5600);
	KUNIT_EXPECT_LT(test, out.b, 0x5800);

	/* == green 140 - bt709 enc == */
	out.a = 0xffff;
	out.r = 0x0;
	out.g = 0x8c8c;
	out.b = 0x0;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 30 */
	KUNIT_EXPECT_GT(test, out.r, 0x6400);
	KUNIT_EXPECT_LT(test, out.r, 0x6600);

	/* U 0 */
	KUNIT_EXPECT_LT(test, out.g, 0x100);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x100);

	/* == blue 140 - bt709 enc == */
	out.a = 0xffff;
	out.r = 0x0;
	out.g = 0x0;
	out.b = 0x8c8c;

	apply_3x4_matrix(&out, &test_matrix_3x4_bt709_enc);

	/* Y 30 */
	KUNIT_EXPECT_GT(test, out.r, 0x900);
	KUNIT_EXPECT_LT(test, out.r, 0xB00);

	/* U 61 */
	KUNIT_EXPECT_GT(test, out.g, 0x3C00);
	KUNIT_EXPECT_LT(test, out.g, 0x3E00);

	/* V 0 */
	KUNIT_EXPECT_LT(test, out.b, 0x100);
}

static struct kunit_case vkms_color_test_cases[] = {
	KUNIT_CASE(vkms_color_test_get_lut_index),
	KUNIT_CASE(vkms_color_test_lerp),
	KUNIT_CASE(vkms_color_test_linear),
	KUNIT_CASE(vkms_color_srgb_inv_srgb),
	KUNIT_CASE(vkms_color_ctm_3x4_50_desat),
	KUNIT_CASE(vkms_color_ctm_3x4_bt709),
	{}
};

static struct kunit_suite vkms_color_test_suite = {
	.name = "vkms-color",
	.test_cases = vkms_color_test_cases,
};

kunit_test_suite(vkms_color_test_suite);

MODULE_DESCRIPTION("Kunit test for VKMS LUT handling");
MODULE_LICENSE("GPL"