#include <binder/ProcessState.h>

#include <private/gui/ComposerService.h>
#include <gui/ISurfaceComposer.h>
#include <gui/SurfaceComposerClient.h>
#include <gui/IGraphicBufferAlloc.h>

#include <ui/PixelFormat.h>
#include <hardware/gralloc.h>
#include <hal/hal_public.h>

#include <getopt.h>

using namespace android;

// #define HAL_PIXEL_FORMAT_BGRA_8888 5
// #define HAL_PIXEL_FORMAT_NV12 0x3231564E
#define OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar 0x7FA00E00
#define OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled 0x7FA00F00

static hw_module_t const *gModule = NULL;
static gralloc_module_t *gAllocMod = NULL;	/* get by force
						 * hw_module_t */
static alloc_device_t *gAllocDev = NULL;

static int gfx_init(void)
{

	int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &gModule);
	if (err) {
		printf("FATAL: can't find the %s module",
		       GRALLOC_HARDWARE_MODULE_ID);
		return -1;
	}
	
	gAllocMod = (gralloc_module_t *) gModule;

	return 0;
}

static int
gfx_alloc(uint32_t w, uint32_t h, int format,
	  int usage, buffer_handle_t * handle, int32_t * stride)
{

	int err;

	if (!gAllocDev) {
		if (!gModule) {
			if (gfx_init()) {
				printf("can't find the %s module",
				       GRALLOC_HARDWARE_MODULE_ID);
				return -1;
			}
		}

		err = gralloc_open(gModule, &gAllocDev);
		if (err) {
			printf("FATAL: gralloc open failed\n");
			return -1;
		}
	}

	err = gAllocDev->alloc(gAllocDev, w, h, format, usage, handle, stride);
	if (err) {
		printf("alloc(%u, %u, %d, %08x, ...) failed %d (%s)\n",
		       w, h, format, usage, err, strerror(-err));
	}

	return err;
}

static int gfx_free(buffer_handle_t handle)
{

	int err;

	if (!gAllocDev) {
		if (!gModule) {
			if (gfx_init()) {
				printf("can't find the %s module",
				       GRALLOC_HARDWARE_MODULE_ID);
				return -1;
			}
		}

		err = gralloc_open(gModule, &gAllocDev);
		if (err) {
			printf("FATAL: gralloc open failed\n");
			return -1;
		}
	}

	err = gAllocDev->free(gAllocDev, handle);
	if (err) {
		printf("free(...) failed %d (%s)\n", err, strerror(-err));
	}

	return err;
}

static int
gfx_lock(buffer_handle_t handle, int usage,
	 int left, int top, int width, int height, void **vaddr)
{

	int err;

	if (!gAllocMod) {
		if (gfx_init()) {
			printf("can't find the %s module",
			       GRALLOC_HARDWARE_MODULE_ID);
			return -1;
		}
	}

	err = gAllocMod->lock(gAllocMod, handle, usage,
			      left, top, width, height, vaddr);
//	printf("gfx_lock: handle is %x, usage is %x, vaddr is %x.\n",
//	       (unsigned int)handle, usage, (unsigned int)*vaddr);

	if (err) {
		printf("lock(...) failed %d (%s).\n", err, strerror(-err));
		return -1;
	}
	
	return err;
}

static int gfx_unlock(buffer_handle_t handle)
{

	int err;

	if (!gAllocMod) {
		if (gfx_init()) {
			printf("can't find the %s module",
			       GRALLOC_HARDWARE_MODULE_ID);
			return -1;
		}
	}

	err = gAllocMod->unlock(gAllocMod, handle);
	if (err) {
		printf("unlock(...) failed %d (%s)", err, strerror(-err));
		return -1;
	}

	return err;
}

static int
gfx_Blit(buffer_handle_t src, buffer_handle_t dest, int w, int h, int x, int y)
{
	int err;

	if (!gAllocMod) {
		if (gfx_init()) {
			printf("can't find the %s module",
			       GRALLOC_HARDWARE_MODULE_ID);
			return -1;
		}
	}

	IMG_gralloc_module_public_t *GrallocMod =
	    (IMG_gralloc_module_public_t *) gModule;

#ifdef MRFLD_GFX
	err = GrallocMod->Blit(GrallocMod, src, dest, w, h, 0, 0, 0);
#else
	err = GrallocMod->Blit2(GrallocMod, src, dest, w, h, 0, 0);
#endif

	if (err) {
		printf("Blit(...) failed %d (%s)", err, strerror(-err));
		return -1;
	}

	return err;
}

void help()
{
	printf("gfx-test:\n");
	printf("	-w/--srcW <width> -h/--srcH <height>\n");
	printf("	-k/--dstW <width> -g/--dstH <height>\n");
	printf("	-a/--blitW <width> -b/--blitH <height>\n");
	printf("	-m/--allocM <0: server, 1: native>\n");
}

#define ListSize 12

int main(int argc, char *argv[])
{
	//for allocator test
	int AllocMethod = 0;
	int Width;
	int Height;
	int Stride;
	int ColorFormat;
	char *Name;

	//for Blit test
	buffer_handle_t SrcHandle, DstHandle;
	int SrcWidth = 720, SrcHeight = 1280, SrcStride;
	int DstWidth = 720, DstHeight = 1280, DstStride;
	int BlitWidth = SrcWidth, BlitHeight = SrcHeight;
	void *SrcPtr[3];
	void *DstPtr[3];
	
    const char *short_opts = "a:b:c:d:e:f:g:h:i:j:k:l:m:n:o:p:q:r:s:t:q:u:v:w:x:y:z:?";
    const struct option long_opts[] = {
						{"help", no_argument, NULL, '?'},
						{"srcW", required_argument, NULL, 'w'},
						{"srcH", required_argument, NULL, 'h'},
						{"dstW", required_argument, NULL, 'k'},
						{"dstH", required_argument, NULL, 'g'},
						{"blitW", required_argument, NULL, 'a'},
						{"blitH", required_argument, NULL, 'b'},
						{"allocM", required_argument, NULL, 'm'},
						{0, 0, 0, 0}
    };

    char c;
    while ((c = getopt_long(argc, argv, short_opts, long_opts, NULL) ) != EOF) {
        switch (c) {
                case 'a':
                    BlitWidth = atoi(optarg);
                    break;

                case 'b':
                    BlitHeight = atoi(optarg);
                    break;

                case 'w':
                    SrcWidth = atoi(optarg);
                    break;

                case 'h':
                    SrcHeight = atoi(optarg);
                    break;

                case 'k':
                    DstWidth = atoi(optarg);
                    break;

                case 'g':
                    DstHeight = atoi(optarg);
                    break;

                case '?':
                    help();
                    return 1;

                case 'm':
                    AllocMethod = atoi(optarg);
                    break;

       }
    }

	android::ProcessState::self()->startThreadPool();

	struct Params {
		int Width;
		int Height;
		int ColorFormat;
		char *Name;
	};

	Params ParamList[ListSize] = {
		{320, 240, HAL_PIXEL_FORMAT_BGRA_8888,
		 "HAL_PIXEL_FORMAT_BGRA_8888"},
		{320, 240, HAL_PIXEL_FORMAT_NV12, "HAL_PIXEL_FORMAT_NV12"},
		{320, 240, OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar,
		 "OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar"},
		{720, 480, HAL_PIXEL_FORMAT_BGRA_8888,
		 "HAL_PIXEL_FORMAT_BGRA_8888"},
		{720, 480, HAL_PIXEL_FORMAT_NV12, "HAL_PIXEL_FORMAT_NV12"},
		{720, 480, OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar,
		 "OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar"},
		{1280, 720, HAL_PIXEL_FORMAT_BGRA_8888,
		 "HAL_PIXEL_FORMAT_BGRA_8888"},
		{1280, 720, HAL_PIXEL_FORMAT_NV12, "HAL_PIXEL_FORMAT_NV12"},
		{1280, 720, OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar,
		 "OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar"},
		{1920, 1080, HAL_PIXEL_FORMAT_BGRA_8888,
		 "HAL_PIXEL_FORMAT_BGRA_8888"},
		{1920, 1080, HAL_PIXEL_FORMAT_NV12, "HAL_PIXEL_FORMAT_NV12"},
		{1920, 1080, OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar,
		 "OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar"},
	};

	buffer_handle_t Handle = NULL;

	// format memory structure test
	for (int i = 0; i < ListSize; i++) {
		Width = ParamList[i].Width;
		Height = ParamList[i].Height;
		ColorFormat = ParamList[i].ColorFormat;
		Name = ParamList[i].Name;

		sp < GraphicBuffer > graphicBuffer;

		if (AllocMethod == 0) {
			uint32_t usage =
			    GraphicBuffer::USAGE_HW_TEXTURE | GraphicBuffer::
			    USAGE_HW_RENDER;
			int32_t error;

			sp < ISurfaceComposer >
			    composer(ComposerService::getComposerService());
			sp < IGraphicBufferAlloc > GraphicBufferAlloc =
			    composer->createGraphicBufferAlloc();

			graphicBuffer =
			    GraphicBufferAlloc->createGraphicBuffer(Width,
								    Height,
								    ColorFormat,
								    usage,
								    &error);

			if (graphicBuffer.get() == NULL) {
				printf("GFX createGraphicBuffer failed\n");
				return 0;
			}

			Stride = graphicBuffer->getStride();
			Handle = graphicBuffer->handle;

		} else {
			int usage =
			    GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;

			if (gfx_alloc
			    (Width, Height, ColorFormat, usage, &Handle,
			     &Stride)
			    != 0) {
				printf("Gralloc allocate failed\n");
				return 0;
			}

		}

		printf("%s\n", Name);
		printf
		    ("	gfx handle 0x%08x, Width=%d, Height=%d, Stride=%d, ColorFormat=0x%08x\n",
		     Handle, Width, Height, Stride, ColorFormat);
		IMG_native_handle_t *h = (IMG_native_handle_t *) Handle;
		printf
		    ("	IMG_native_handle_t iWidth=%d, iHeight=%d, iFormat=0x%08x\n\n",
		     h->iWidth, h->iHeight, h->iFormat);

		if (AllocMethod > 0)
			gfx_free(Handle);
	}

	// Blit test, from HAL_PIXEL_FORMAT_BGRA_8888 to HAL_PIXEL_FORMAT_NV12
	printf("Start Blit test ............\n");
	int usage = GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_HW_RENDER;

	// src rgba 
	ColorFormat = HAL_PIXEL_FORMAT_BGRA_8888;
	if (gfx_alloc(SrcWidth, SrcHeight, ColorFormat, usage, &SrcHandle, &SrcStride)
	    != 0) {
		printf
		    ("Gralloc allocate handle1 HAL_PIXEL_FORMAT_BGRA_8888 failed\n");
		return 0;
	}
	// Fill data
	if (gfx_lock
	    (SrcHandle, usage | GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, SrcWidth,
	     SrcHeight, &SrcPtr[0]) != 0)
		return 0;
	int data = 0x00FF0000;	// AA RR GG BB
	for (int i = 0; i < SrcStride * SrcHeight; i++)
		memcpy(SrcPtr[0] + i * 4, &data, 4);
	// dump to file
	FILE *fp1 = fopen("/data/dump.rgb", "wb");
	fwrite(SrcPtr[0], 1, SrcStride * SrcHeight * 4, fp1);
	fclose(fp1);
	gfx_unlock(SrcHandle);
	//============================================================================

	// dest nv12
	ColorFormat = HAL_PIXEL_FORMAT_NV12;
//	ColorFormat = OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar;
	if (gfx_alloc(DstWidth, DstHeight, ColorFormat, usage, &DstHandle, &DstStride)
	    != 0) {
		printf
		    ("Gralloc allocate handle2 HAL_PIXEL_FORMAT_NV12 failed\n");
		return 0;
	}
	//===========================================================================

	printf("\nSRC size: %dx%d, stride:%d\n", SrcWidth, SrcHeight, SrcStride);
	printf("DST size: %dx%d, stride:%d\n", DstWidth, DstHeight, DstStride);
	printf("Blit RECT: %dx%d \n", BlitWidth, BlitHeight);

	// blit start
	if (gfx_Blit(SrcHandle, DstHandle, BlitWidth, BlitHeight, 0, 0) != 0) {
		printf("Gralloc Blit failed\n");
		return 0;
	}

	//============================================================================
	// dump data of dest
	if (gfx_lock
	    (DstHandle, usage | GRALLOC_USAGE_SW_WRITE_OFTEN, 0, 0, DstWidth,
	     DstHeight, &DstPtr[0]) != 0)
		return 0;
	FILE *fp2 = fopen("/data/dump.yuv", "wb");
	fwrite(DstPtr[0], 1, DstStride * DstHeight * 1.5, fp2);
	fclose(fp2);
	gfx_unlock(DstHandle);

	// release handles
	gfx_free(SrcHandle);
	gfx_free(DstHandle);

	printf("Complete Blit test ............\n");
	return 1;
}