#include <stdbool.h>
#include <time.h>
#include <linux/version.h>
#include <linux/videodev2.h>
#include <stdbool.h>

#if LINUX_VERSION_CODE > KERNEL_VERSION (3, 0, 36)
#include <linux/uvcvideo.h>
#include <ctype.h>
#include <pthread.h>

#endif
#include "ImageProc.h"
#include "libyuv.h"
#include "charencode.h"
#include "jpeg.h"
#include "watermark.h"
#include "SonixCamera/XUOptDev.h"
#include "SonixCamera/SonixCamera.h"

#define LIBENC_ARRAY_ELEMS(a)  (sizeof(a) / sizeof(a[0]))

#define XU_SONIX_SYS_ASIC_RW	      			0x01

#if LINUX_VERSION_CODE > KERNEL_VERSION (3, 0, 36)
#define UVC_SET_CUR					0x01
#define UVC_GET_CUR					0x81
#define UVCIOC_CTRL_MAP		_IOWR('u', 0x20, struct uvc_xu_control_mapping)
#define UVCIOC_CTRL_QUERY	_IOWR('u', 0x21, struct uvc_xu_control_query)
#else
#define UVCIOC_CTRL_ADD		_IOW('U', 1, struct uvc_xu_control_info)
#define UVCIOC_CTRL_MAP		_IOWR('U', 2, struct uvc_xu_control_mapping)
#define UVCIOC_CTRL_GET		_IOWR('U', 3, struct uvc_xu_control)
#define UVCIOC_CTRL_SET		_IOW('U', 4, struct uvc_xu_control)
#endif

struct buffer {
	void *                  start;
	size_t                  length;
};

static char            dev_name[32];
static int              fd              = -1;
struct buffer *         buffers         = NULL;
static unsigned int     n_buffers       = 0;

static int *rgb = NULL;
static int *ybuf = NULL;

static int yuv_tbl_ready=0;
static int y1192_tbl[256];
static int v1634_tbl[256];
static int v833_tbl[256];
static int u400_tbl[256];
static int u2066_tbl[256];

static int IMG_WIDTH = 640;
static int IMG_HEIGHT = 480;

static uint32_t img_pixelformat = 0;
static int camera_version = 0;
static char camera_true_version[64] = {0};
static char camera_sn[32] = {0};
static char camera_name[32] = {0};
static int camera_index = 0;

static JavaVM *sg_jvm = NULL;
static JNIEnv *sg_jenv = NULL;
static jobject sg_obj = NULL;

static struct camera_info{
	char name[32];
	int resolution_num;
	int resolution[20][2];
}CameraInfo[16];

static int CameraInfoNum = 0;

static bool wm_enable = false;

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
static int init_module = 0;
static bool cam_inited = false;

static void mjpegToRGBA(const uint8_t *data, int length);

static int errnoexit(const char *s);
static int xioctl(int fd, int request, void *arg);

static int opendevice(int videoid);
static int initdevice(int width, int height, const char *name, bool define_camera);
static int initmmap(void);
static int startcapturing(void);

static int readframeonce(void);
static int readframe(void);
static void processimage (const void *p, int length);

static int stopcapturing(void);
static int uninitdevice(void);
static int closedevice(void);

static int handshake(void);

static void yuyv422toABGRY(unsigned char *src);

static int errnoexit(const char *s) {
	LOGE("%s error %d, %s", s, errno, strerror (errno));
	return ERROR_LOCAL;
}

static int xioctl(int fd, int request, void *arg) {
	int r;
//	LOGE("xioctl(int fd, int request, void *arg)");
	do
		r = ioctl(fd, request, arg);
	while (-1 == r && EINTR == errno);

	return r;
}

static int opendevice(int i) {
	struct stat st;

	sprintf(dev_name, "/dev/video%d", i);

	LOGI("尝试打开Camera %s...", dev_name);

	if (-1 == stat(dev_name, &st)) {
		LOGE("Cannot identify '%s': %d, %s", dev_name, errno, strerror (errno));
		return ERROR_LOCAL;
	}

	if (!S_ISCHR(st.st_mode)) {
		LOGE("%s is no device", dev_name);
		return ERROR_LOCAL;
	}
    memset(camera_true_version, 0, sizeof(camera_true_version));
	if (SonixCam_Init(i)) {
		char buf[100] = {0};
		if (SonixCam_GetFwVersion(buf, 100, true)) {
			LOGI("fw version=%s", buf);
			strcpy(camera_true_version, buf);
		}
		SonixCam_UnInit();
	}

	fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);

	if (-1 == fd) {
		LOGE("Open Fail '%s': %d, %s", dev_name, errno, strerror (errno));
		return ERROR_LOCAL;
	}
	LOGI("Open Success fd: %d", fd);
	return SUCCESS_LOCAL;
}

static int initdevice(int width, int height, const char *name, bool ay_camera) {
	LOGE("initdevice width %d height %d", width, height);

	struct v4l2_capability cap;
	struct v4l2_cropcap cropcap;
	struct v4l2_crop crop;
	struct v4l2_format fmt;
	unsigned int min;

	memset(camera_name, 0, sizeof(camera_name));
	memset(camera_sn, 0, sizeof(camera_sn));
	camera_version = -1;

	if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
		if (EINVAL == errno) {
			LOGE("%s is no V4L2 device", dev_name);
			return ERROR_LOCAL;
		} else {
			return errnoexit("VIDIOC_QUERYCAP");
		}
	}
	LOGE("initdevice 查询设备能力...");
	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
		LOGE("%s is no video capture device", dev_name);
		return ERROR_LOCAL;
	}

	if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
		LOGE("%s does not support streaming i/o", dev_name);
		return ERROR_LOCAL;
	}

	LOGI("Drive = %s, DevName = %s, path = %s, aycam = %d", cap.driver, cap.card, cap.bus_info, ay_camera);

	if (name != NULL) {
		LOGI("repect name: %s", name);
		if (strlen(name) != strlen(cap.card)) {
			LOGE("name not match");
			return ERROR_USB_NAME;
		}
		for (int x = 0, y = 0; x < strlen(name) && y < strlen(cap.card); ++x, ++y) {
			if (toupper(name[x]) != toupper(cap.card[y])) {
				LOGE("name not match");
				return ERROR_USB_NAME;
			}
		}
	}

	if (ay_camera) {
		if (handshake() != 0) {
            LOGE("handshake fail");
			return ERROR_AY_CAMERA;
		}
	}

	struct v4l2_fmtdesc fmtdesc;
	struct v4l2_frmsizeenum frmsize;
	int resolution_table[8][20][2];
	int resolution_num = 0;
	uint32_t support_pixelformat[16] = {0};
	int support_pixelformat_num = 0;

	fmtdesc.index=0;
	fmtdesc.type=V4L2_BUF_TYPE_VIDEO_CAPTURE;

	support_pixelformat_num = 0;

	CameraInfoNum = 0;
	CLEAR(CameraInfo);

	LOGE("Support format:");
	while(xioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc) != -1) {
		LOGE("%d.%s 0x%x flag: %d",fmtdesc.index+1, fmtdesc.description, fmtdesc.pixelformat, fmtdesc.flags);

		strcpy(CameraInfo[fmtdesc.index].name, fmtdesc.description);

		frmsize.pixel_format = fmtdesc.pixelformat;
		frmsize.index = 0;

		while (xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) != -1) {
			if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
				LOGE("A %dx%d\n", frmsize.discrete.width, frmsize.discrete.height);
				resolution_table[fmtdesc.index][resolution_num][0] = frmsize.discrete.width;
				resolution_table[fmtdesc.index][resolution_num][1] = frmsize.discrete.height;
				resolution_num++;

				CameraInfo[fmtdesc.index].resolution[frmsize.index][0] = frmsize.discrete.width;
				CameraInfo[fmtdesc.index].resolution[frmsize.index][1] = frmsize.discrete.height;
				CameraInfo[fmtdesc.index].resolution_num++;
			} else if (frmsize.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
				LOGE("B %dx%d\n", frmsize.discrete.width, frmsize.discrete.height);
			}
			frmsize.index++;
		}

		if (frmsize.index == 0) {
			return ERROR_LOCAL;
		}

		support_pixelformat[support_pixelformat_num++] = fmtdesc.pixelformat;
		fmtdesc.index++;

		CameraInfoNum++;
	}

	if (fmtdesc.index == 0) {
		return ERROR_LOCAL;
	}

	img_pixelformat = 0;
	int pfidx = 0;

	// 支持MJPEG和YUYV格式，优先选择MJPEG模式
	for (int i = 0; i < support_pixelformat_num; ++i) {
		if (support_pixelformat[i] == V4L2_PIX_FMT_MJPEG) {
			img_pixelformat = V4L2_PIX_FMT_MJPEG;
			pfidx = i;
			break;
		} else if (support_pixelformat[i] == V4L2_PIX_FMT_YUYV) {
			img_pixelformat = V4L2_PIX_FMT_YUYV;
			pfidx = i;
		}
	}

	if (img_pixelformat == 0) {
		LOGI("None of pixelformat support");
		return ERROR_LOCAL;
	}

	// 匹配最佳分辨率
	int optimal = 0;

	for (int i = 1; i < resolution_num; ++i) {
		if ((abs(width - resolution_table[pfidx][i][0]) < abs(width - resolution_table[pfidx][optimal][0])) &&
			(abs(height - resolution_table[pfidx][i][1]) < abs(height - resolution_table[pfidx][optimal][1]))) {
			optimal = i;
		}
	}

	LOGE("设置的分辨率 img_pixelformat %d pfidx %d optimal %d  %dx%d", img_pixelformat, pfidx, optimal,  resolution_table[pfidx][optimal][0], resolution_table[pfidx][optimal][1]);
/*
	CLEAR(cropcap);
	cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	LOGE("initdevice 设置video捕获模式...");
	if (0 == xioctl(fd, VIDIOC_CROPCAP, &cropcap)) {
		crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		crop.c = cropcap.defrect;

		if (-1 == xioctl(fd, VIDIOC_S_CROP, &crop)) {
			LOGE("initdevice VIDIOC_S_CROP fail");
			switch (errno) {
				case EINVAL:
					break;
				default:
					break;
			}
		}
	} else {
		LOGE("initdevice VIDIOC_CROPCAP fail");
	}
	LOGE("initdevice 设置video捕获模式完毕");
*/
    CLEAR(fmt);
    fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    IMG_WIDTH = resolution_table[pfidx][optimal][0];
    IMG_HEIGHT = resolution_table[pfidx][optimal][1];

    fmt.fmt.pix.width = IMG_WIDTH;
    fmt.fmt.pix.height = IMG_HEIGHT;

    fmt.fmt.pix.pixelformat = img_pixelformat;
    fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

    struct v4l2_format fmt2;
    CLEAR(fmt2);
    fmt2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
    if(-1 == xioctl(fd, VIDIOC_G_FMT, &fmt2)) {
        LOGI("VIDIOC_G_FMT error");
    } else {
        if (fmt2.fmt.pix.width == IMG_WIDTH && fmt2.fmt.pix.height == IMG_HEIGHT && fmt2.fmt.pix.pixelformat == img_pixelformat) {
            LOGI("无需设置！！");
        } else {
            if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
                return errnoexit("VIDIOC_S_FMT");

            CLEAR(fmt2);
            fmt2.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
            if(-1 == xioctl(fd, VIDIOC_G_FMT, &fmt2)) {
                LOGI("VIDIOC_G_FMT error");
            }

            img_pixelformat = fmt2.fmt.pix.pixelformat;

            LOGI("复查：W:%d, H:%d, %s", fmt2.fmt.pix.width, fmt2.fmt.pix.height, V4L2_PIX_FMT_MJPEG == fmt2.fmt.pix.pixelformat? "V4L2_PIX_FMT_MJPEG" : "V4L2_PIX_FMT_YUYV");
        }
    }

	min = fmt.fmt.pix.width * 2;
	if (fmt.fmt.pix.bytesperline < min)
		fmt.fmt.pix.bytesperline = min;
	min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
	if (fmt.fmt.pix.sizeimage < min)
		fmt.fmt.pix.sizeimage = min;

	LOGE("initdevice 设置内存映射...");

	return initmmap();
}
#if 0
int XU_Get_Cur(__u8 xu_unit, __u8 xu_selector, __u16 xu_size, __u8 *xu_data)
{
	int err=0;
#if LINUX_VERSION_CODE > KERNEL_VERSION (3, 0, 36)
	struct uvc_xu_control_query xctrl;
	xctrl.unit = xu_unit;
	xctrl.selector = xu_selector;
	xctrl.query = UVC_GET_CUR;
	xctrl.size = xu_size;
	xctrl.data = xu_data;
	err=ioctl(fd, UVCIOC_CTRL_QUERY, &xctrl);
#else
	struct uvc_xu_control xctrl;
    xctrl.unit = xu_unit;
    xctrl.selector = xu_selector;
    xctrl.size = xu_size;
    xctrl.data = xu_data;
    err=ioctl(fd, UVCIOC_CTRL_GET, &xctrl);
#endif
	return err;
}

int XU_Set_Cur(__u8 xu_unit, __u8 xu_selector, __u16 xu_size, __u8 *xu_data)
{
	int err=0;
#if LINUX_VERSION_CODE > KERNEL_VERSION (3, 0, 36)
	struct uvc_xu_control_query xctrl;
	xctrl.unit = xu_unit;
	xctrl.selector = xu_selector;
	xctrl.query = UVC_SET_CUR;
	xctrl.size = xu_size;
	xctrl.data = xu_data;
	err=ioctl(fd, UVCIOC_CTRL_QUERY, &xctrl);
#else
	struct uvc_xu_control xctrl;
    xctrl.unit = xu_unit;
    xctrl.selector = xu_selector;
    xctrl.size = xu_size;
    xctrl.data = xu_data;
    err=ioctl(fd, UVCIOC_CTRL_SET, &xctrl);
#endif
	return err;
}

static bool XU_ReadFromASIC(uint16_t addr, uint8_t *pValue)
{
	int ret = 0;
	__u8 ctrldata[4];

	//uvc_xu_control parmeters
	__u8 xu_unit= 3;
	__u8 xu_selector= XU_SONIX_SYS_ASIC_RW;
	__u16 xu_size= 4;
	__u8 *xu_data= ctrldata;

	xu_data[0] = (addr & 0xFF);
	xu_data[1] = ((addr >> 8) & 0xFF);
	xu_data[2] = 0x0;
	xu_data[3] = 0xFF;		/* Dummy Write */

	/* Dummy Write */
	if ((ret=XU_Set_Cur(xu_unit, xu_selector, xu_size, xu_data)) < 0)
	{
		LOGI("ioctl(UVCIOC_CTRL_SET) FAILED (%i) \n",ret);
		//if(ret==EINVAL)			printf("Invalid arguments\n");
		return false;
	}

	/* Asic Read */
	xu_data[3] = 0x00;
	if ((ret=XU_Get_Cur(xu_unit, xu_selector, xu_size, xu_data)) < 0)
	{
		LOGI("ioctl(UVCIOC_CTRL_GET) FAILED (%i)\n",ret);
		//if(ret==EINVAL)			printf("Invalid arguments\n");
		return false;
	}
	*pValue = xu_data[2];
	if(ret < 0)
		return false;
	return true;
}

static bool XU_WriteToASIC(uint16_t addr, uint8_t value)
{
	int ret = 0;
	__u8 ctrldata[4];

	//uvc_xu_control parmeters
	__u8 xu_unit= 3;
	__u8 xu_selector= XU_SONIX_SYS_ASIC_RW;
	__u16 xu_size= 4;
	__u8 *xu_data= ctrldata;

	xu_data[0] = (addr & 0xFF);			/* Addr Low */
	xu_data[1] = ((addr >> 8) & 0xFF);	/* Addr High */
	xu_data[2] = value;
	xu_data[3] = 0x0;					/* Normal Write */

	/* Normal Write */
	if ((ret=XU_Set_Cur(xu_unit, xu_selector, xu_size, xu_data)) < 0)
	{
		LOGI("ioctl(UVCIOC_CTRL_SET) FAILED (%i) \n",ret);
		//if(ret==EINVAL)			printf("Invalid arguments\n");
		return false;
	}

	if(ret < 0)
		return false;
	return true;
}
#endif

static void Camencrypt(uint8_t *buffer,uint16_t size ,uint32_t CamCrpt)
{
	uint32_t CamKey=0,CamM1=0,CamIA1=0,CamIC1=0;
	uint16_t idx = 0;
	uint32_t Key_0;

	CamKey=CamCrpt*0x1398+0x1F678632;
	CamM1=(CamCrpt%0x693E)+0x91305EA3;
	CamIA1=CamCrpt*35-0x98DA63CC;
	CamIC1=CamCrpt*17+0xB01A4967;
	if(CamKey == 0 ) Key_0= 1;
	else Key_0= CamKey;
	while( idx < size )
	{
		Key_0= CamIA1 * (Key_0% CamM1 ) + CamIC1;
		buffer[idx++] ^= (uint8_t)((( Key_0>>20)+0x9e)&0xFF);
	}
}

static int handshake(void)
{
	const uint8_t comm_xor_code_1[8]=  {0x98,0x32,0xa0,0xaa,0x02,0x0d,0x09,0xa9};
	const uint8_t comm_xor_code_2[8]=  {0x65,0x89,0xA3,0xEE,0x69,0x8D,0x06,0xE2};

	uint8_t cmd[16] = {0};
	uint32_t seed, seed_client;

	uint8_t op[11] = {0};

	srand(time(NULL));

	for (int i = 0; i < sizeof(op); ++i) {
		do {
			op[i] = rand();
		} while (op[i] == 0 || op[i] == 0xFF);
	}
	seed = (op[0]<<24)+(op[1]<<16)+(op[2]<<8)+op[3];

//	for (int i = 0; i < sizeof(op); ++i) {
//		LOGI("初始 %d - 0x%02X", i, op[i]);
//	}

	Camencrypt(op, sizeof(op), seed);

//	for (int i = 0; i < sizeof(op); ++i) {
//		LOGI("Camencrypt后 %d - 0x%02X", i, op[i]);
//	}

	cmd[0] = 0x0A;
	cmd[1] = (seed>>24)&0xFF;
	cmd[2] = (seed>>16)&0xFF;
	cmd[3] = (seed>>8)&0xFF;
	cmd[4] = seed&0xFF;
	memcpy(cmd+5, op, sizeof(op));

//	for (int i = 0; i < sizeof(cmd); ++i) {
//		LOGI("CMD %d - 0x%02X", i, cmd[i]);
//	}

	for (int i = 0; i < sizeof(cmd); ++i) {
		if (i < sizeof(comm_xor_code_1)) {
			cmd[i] ^= comm_xor_code_1[i];
		} else {
			cmd[i] ^= comm_xor_code_1[i-sizeof(comm_xor_code_1)];
		}
	}

//	for (int i = 0; i < sizeof(cmd); ++i) {
//		LOGI("发送的CMD %d - 0x%02X", i, cmd[i]);
//	}

	uint8_t ver[4];
	for (int i = 0; i < 4; ++i) {
		if (!XU_ReadFromASIC(0x0474 + i, ver + i))
			return -2;

//		LOGI("版本 0x%02X", ver[i]);
	}

	camera_version = 0;
	for (int i = 0; i < 4; ++i) {
		camera_version *= 10;
		camera_version += (ver[i]>>4)&0x0F;
		camera_version *= 10;
		camera_version += ver[i]&0x0F;
	}
//	LOGI("版本 %ld", camera_version);

	for (int i = 0; i < 16; ++i) {
		uint8_t dat = 0;
		if (!XU_ReadFromASIC(0x0CFA + i, &dat))
			return -2;

//        LOGI("首次读出的<%d>: 0x%02X", i, dat);
		//if (dat != 0xFF)
		//    return -1;
	}
////
//    LOGI("写入数据");
	for (int i = 1; i < sizeof(cmd); ++i) {
		if (!XU_WriteToASIC(0x0CFA + i, cmd[i])) {
			return -2;
		}
	}
	if (!XU_WriteToASIC(0x0CFA, cmd[0])) {
		return -2;
	}

	usleep(100000);

//    LOGI("读取数据");
	for (int i = 0; i < sizeof(cmd); ++i) {
		if (!XU_ReadFromASIC(0x0CFA + i, cmd + i)) {
			return -2;
		}
	}

//	for (int i = 0; i < sizeof(cmd); ++i) {
//		LOGI("读出的CMD %d - 0x%02X", i, cmd[i]);
//	}

	for (int i = 0; i < sizeof(cmd); ++i) {
		if (i < sizeof(comm_xor_code_2)) {
			cmd[i] ^= comm_xor_code_2[i];
		} else {
			cmd[i] ^= comm_xor_code_2[i-sizeof(comm_xor_code_2)];
		}
	}

//	for (int i = 0; i < sizeof(cmd); ++i) {
//		LOGI("异或后 %d - 0x%02X", i, cmd[i]);
//	}

	memcpy(op, cmd + 5, 11);
	seed_client = (cmd[1]<<24)+(cmd[2]<<16)+(cmd[3]<<8)+cmd[4];

	if (seed != seed_client || cmd[0] != 0x8A) {
		return -1;
	}

	Camencrypt(op, sizeof(op), seed_client);

//    for (int i = 0; i < sizeof(op); ++i) {
//        LOGI("解密后 %d - 0x%02X", i, op[i]);
//    }

	const uint8_t cam_sn[] = {0x01, 0x09, 0x09, 0x04, 0x01, 0x01, 0x02, 0x02};

	if (!memcmp(op, cam_sn, sizeof(cam_sn))) {
//		LOGI("握手成功");
		strcpy(camera_sn, "0109090401010202");
		return 0;
	}
//	LOGI("握手失败");
	return -1;
}

static int initmmap(void) {
	struct v4l2_requestbuffers req;

	CLEAR(req);

	req.count = 4;
	req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	req.memory = V4L2_MEMORY_MMAP;

	if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
		if (EINVAL == errno) {
			LOGE("%s does not support memory mapping", dev_name);
			return ERROR_LOCAL;
		} else {
			return errnoexit("VIDIOC_REQBUFS");
		}
	}
	LOGE("initdevice initmmap calloc = %d", req.count*sizeof(*buffers));
	if (req.count < 2) {
		LOGE("Insufficient buffer memory on %s", dev_name);
		return ERROR_LOCAL;
	}

	buffers = calloc(req.count, sizeof(*buffers));

	if (!buffers) {
		LOGE("Out of memory");
		return ERROR_LOCAL;
	}

	for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
		struct v4l2_buffer buf;

		CLEAR(buf);

		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.index = n_buffers;

		if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
			return errnoexit("VIDIOC_QUERYBUF");

		buffers[n_buffers].length = buf.length;

		LOGI("buff[%d] length = %ld offset = %ld", n_buffers, buf.length, buf.m.offset);

		buffers[n_buffers].start = mmap(NULL, buf.length,
										PROT_READ | PROT_WRITE, MAP_SHARED, fd, buf.m.offset);
		LOGI("buff[%d] start = %lu", n_buffers, (unsigned long)buffers[n_buffers].start);

		if (MAP_FAILED == buffers[n_buffers].start)
			return errnoexit("mmap");
	}

	LOGI("initmmap OK");

	return SUCCESS_LOCAL;
}

static int startcapturing(void) {
	unsigned int i;
	enum v4l2_buf_type type;

	for (i = 0; i < n_buffers; ++i) {
		struct v4l2_buffer buf;

		CLEAR(buf);

		buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
		buf.memory = V4L2_MEMORY_MMAP;
		buf.index = i;

		if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
			return errnoexit("VIDIOC_QBUF");
	}
	LOGE("startcapturing startcapturing");
	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

	if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
		return errnoexit("VIDIOC_STREAMON");

	return SUCCESS_LOCAL;
}

static int readframeonce(void) {
	int err_cnt = 0;

    if (!cam_inited) {
        return ERROR_LOCAL;
    }

	for (;;) {
		fd_set fds;
		struct timeval tv;
		int r;

		FD_ZERO(&fds);
		FD_SET(fd, &fds);

		tv.tv_sec = 2;
		tv.tv_usec = 0;

		r = select(fd + 1, &fds, NULL, NULL, &tv);

		if (-1 == r) {
			if (EINTR == errno)
				continue;

			return errnoexit("select");
		}

		if (0 == r) {
			LOGE("select timeout");

			return ERROR_LOCAL;

		}
//        handshake();
		r = readframe();

		if (r == 1)
			break;
		else {
			err_cnt++;
			if (err_cnt >= 10) {
                return r;
            }
		}
	}

	return SUCCESS_LOCAL;
}

static void processimage(const void *p, int length) {
	if (img_pixelformat == V4L2_PIX_FMT_YUYV)
		yuyv422toABGRY((unsigned char *) p);
	else if (img_pixelformat == V4L2_PIX_FMT_MJPEG) {
		mjpegToRGBA((unsigned char *) p, length);
	}

	if (wm_enable) {
        AddWatermark((uint8_t *)rgb);
    }
}

static int readframe(void) {
	struct v4l2_buffer buf;
	unsigned int i;

	CLEAR(buf);

	buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	buf.memory = V4L2_MEMORY_MMAP;
    if (buffers == NULL){
        return 0;
    }
	if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
		switch (errno) {
			case EAGAIN:
				return 0;
			case EIO:
			default:
				return errnoexit("VIDIOC_DQBUF");
		}
	} else {
//	    LOGI("readframe %d %ld", buf.index, buf.length);
	}

	assert(buf.index < n_buffers);

//	LOGI("readframe %d: 0x%X %ld", buf.index, buffers[buf.index].start, buf.bytesused);
	processimage(buffers[buf.index].start, buf.bytesused);

	if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
		return errnoexit("VIDIOC_QBUF");

	return 1;
}

static int stopcapturing(void) {
	enum v4l2_buf_type type;

	type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

    if (fd <= 0) {
        return SUCCESS_LOCAL;
    }

	if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
		return errnoexit("VIDIOC_STREAMOFF");

	LOGE("stopcaptured!");
	return SUCCESS_LOCAL;
}

static int uninitdevice(void) {
	unsigned int i;

	if (buffers == NULL){
	    return SUCCESS_LOCAL;
	}
	for (i = 0; i < n_buffers; ++i)
		if (-1 == munmap(buffers[i].start, buffers[i].length))
			return errnoexit("munmap");

	free(buffers);
	buffers = NULL;

	LOGE("uninitdeviced!");
	return SUCCESS_LOCAL;
}

static int closedevice(void) {
    LOGI("Close fd: %d", fd);
    if (fd <= 0) {
        return SUCCESS_LOCAL;
    }
	if (-1 == close(fd)) {
		fd = -1;
		return errnoexit("close");
	}

	fd = -1;

	LOGI("Closed!");
	return SUCCESS_LOCAL;
}

static void yuyv422toABGRY(unsigned char *src) {

	int width = 0;
	int height = 0;

	width = IMG_WIDTH;
	height = IMG_HEIGHT;

	int frameSize = width * height * 2;

	int i;

	if ((!rgb || !ybuf)) {
		return;
	}
	int *lrgb = NULL;
	int *lybuf = NULL;

	lrgb = &rgb[0];
	lybuf = &ybuf[0];

	if (yuv_tbl_ready == 0) {
		for (i = 0; i < 256; i++) {
			y1192_tbl[i] = 1192 * (i - 16);
			if (y1192_tbl[i] < 0) {
				y1192_tbl[i] = 0;
			}

			v1634_tbl[i] = 1634 * (i - 128);
			v833_tbl[i] = 833 * (i - 128);
			u400_tbl[i] = 400 * (i - 128);
			u2066_tbl[i] = 2066 * (i - 128);
		}
		yuv_tbl_ready = 1;
	}

	for (i = 0; i < frameSize; i += 4) {
		unsigned char y1, y2, u, v;
		y1 = src[i];
		u = src[i + 1];
		y2 = src[i + 2];
		v = src[i + 3];

		int y1192_1 = y1192_tbl[y1];
		int r1 = (y1192_1 + v1634_tbl[v]) >> 10;
		int g1 = (y1192_1 - v833_tbl[v] - u400_tbl[u]) >> 10;
		int b1 = (y1192_1 + u2066_tbl[u]) >> 10;

		int y1192_2 = y1192_tbl[y2];
		int r2 = (y1192_2 + v1634_tbl[v]) >> 10;
		int g2 = (y1192_2 - v833_tbl[v] - u400_tbl[u]) >> 10;
		int b2 = (y1192_2 + u2066_tbl[u]) >> 10;

		r1 = r1 > 255 ? 255 : r1 < 0 ? 0 : r1;
		g1 = g1 > 255 ? 255 : g1 < 0 ? 0 : g1;
		b1 = b1 > 255 ? 255 : b1 < 0 ? 0 : b1;
		r2 = r2 > 255 ? 255 : r2 < 0 ? 0 : r2;
		g2 = g2 > 255 ? 255 : g2 < 0 ? 0 : g2;
		b2 = b2 > 255 ? 255 : b2 < 0 ? 0 : b2;

		*lrgb++ = 0xff000000 | b1 << 16 | g1 << 8 | r1;
		*lrgb++ = 0xff000000 | b2 << 16 | g2 << 8 | r2;

		if (lybuf != NULL) {
			*lybuf++ = y1;
			*lybuf++ = y2;
		}
	}
}

void InitNVLog(void)
{
	/*if (0 != access("/storage/sdcard0/nvlog", F_OK)) {
        if (0 == mkdir("/storage/sdcard0/nvlog", S_IRWXU | S_IRWXG | S_IRWXO)) {

        }
    }*/
}

void WriteNVLog(const char *fmt, ...)
{
	/*va_list argp;
    char buffer[1024];
    char fname[64];
    FILE *fp;

    sprintf(fname, "/storage/sdcard0/nvlog/log%d.txt", 0);

//    LOGD("WriteNVLog 写文件 log%d.txt", index);

    fp = fopen(fname, "a+");
    if (fp != NULL) {
        time_t time1 = time(NULL);
        struct tm *ts = localtime(&time1);

        sprintf(buffer, "%04d-%02d-%02d %02d:%02d:%02d\t\t", 1900 + ts->tm_year, 1 + ts->tm_mon, ts->tm_mday, ts->tm_hour, ts->tm_min, ts->tm_sec);

        va_start(argp, fmt);
        vsprintf(buffer + strlen(buffer), fmt, argp);
        va_end(argp);

        strcat(buffer, "\r\n");

        fwrite(buffer, 1, strlen(buffer), fp);
        fclose(fp);
    }*/
}

void rgba(JNIEnv* env, jobject thiz, jint type,jbyteArray output) {
	jbyte *outputBuffer = (*env)->GetByteArrayElements(env, output, 0);

	if (!rgb || !ybuf)
		return;
	//0-录像 1-推流
	if (type == 0){
		rgbaToYuvSIMD(IMG_WIDTH, IMG_HEIGHT, (uint8_t *)rgb, (uint8_t *)outputBuffer, BGRA_YUV420SP);
	} else if (type == 1) {
        rgbaToYuvSIMD(IMG_WIDTH, IMG_HEIGHT, (uint8_t *)rgb, (uint8_t *)outputBuffer, RGBA_YUV420P);
	} else if (type == 2) {
		rgbaToYuvSIMD(IMG_WIDTH, IMG_HEIGHT, (uint8_t *)rgb, (uint8_t *)outputBuffer, BGRA_NV21);
	} else {
		rgbaToYuvSIMD(IMG_WIDTH, IMG_HEIGHT, (uint8_t *)rgb, (uint8_t *)outputBuffer, RGBA_NV21);
	}

	(*env)->ReleaseByteArrayElements(env, output, outputBuffer, 0);
}

void pixeltobmp(JNIEnv* env, jobject thiz, jobject bitmap) {
	AndroidBitmapInfo info;
	void* pixels;
	int ret;
	int i;
	int *colors;

	int width = 0;
	int height = 0;

	if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
		LOGE("AndroidBitmap_getInfo() failed ! error=%d", ret);
		return;
	}

	width = info.width;
	height = info.height;

	if (!rgb || !ybuf)
		return;

	if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
		LOGE("Bitmap format is not RGBA_8888 !");
		return;
	}

	if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
		LOGE("AndroidBitmap_lockPixels() failed ! error=%d", ret);
	}

	colors = (int*) pixels;
	int *lrgb = NULL;

	lrgb = &rgb[0];

	if (width == IMG_WIDTH && height == IMG_HEIGHT) {
        for (i = 0; i < IMG_WIDTH * IMG_HEIGHT; i++) {
            *colors++ = *lrgb++;
        }
    } else {
        for (int y = 0; y < IMG_HEIGHT && y < height; ++y) {
            for (int x = 0; x < IMG_WIDTH && x < width; ++x) {
                colors[y * width + x] = lrgb[y * IMG_WIDTH + x];
            }
        }
    }

	AndroidBitmap_unlockPixels(env, bitmap);
}

jint prepareCamera(JNIEnv* env, jobject thiz, jintArray ids, jstring name, jintArray resolution, jboolean ay_camera) {
	int ret;
	char *except_camera_name = NULL;

	InitNVLog();

	jint *ptr_resolution = (*env)->GetIntArrayElements(env, resolution, 0);
	LOGE("打开摄像头 分辨率 （%d x %d）- %d",ptr_resolution[0],ptr_resolution[1], ++init_module);

	if (name != NULL) {
		except_camera_name = (*env)->GetStringUTFChars(env, name, 0);
	}

	jint *ptr_index = (*env)->GetIntArrayElements(env, ids, 0);
	LOGE("打开摄像头 index [%d - %d]",ptr_index[0], ptr_index[1]);

	pthread_mutex_lock(&mutex);
	for (int index = ptr_index[0]; index < ptr_index[1]; ++index) {
		ret = opendevice(index);
		LOGI("open device %d", ret);
		if (ret != ERROR_LOCAL) {
			ret = initdevice(ptr_resolution[0], ptr_resolution[1], except_camera_name, ay_camera);
		}
		if (ret == SUCCESS_LOCAL) {
			camera_index = index;
			break;
		}
		else if (fd != -1) {
			closedevice();
		}
	}

	if (ret == SUCCESS_LOCAL) {
		ret = startcapturing();

		if (ret != SUCCESS_LOCAL) {
			LOGE("device reset.....");
			stopcapturing();
			uninitdevice();
			closedevice();
			LOGE("device resetted");
		}
	}

	if (ret == SUCCESS_LOCAL) {
		rgb = (int *) malloc(sizeof(int) * (IMG_WIDTH * IMG_HEIGHT));
		ybuf = (int *) malloc(sizeof(int) * (IMG_WIDTH * IMG_HEIGHT));
		init_JPEG_turbo();

        cam_inited = true;
	} else {
        cam_inited = false;
    }

	ptr_resolution[0] = IMG_WIDTH;
	ptr_resolution[1] = IMG_HEIGHT;

    LOGE("##### 初始化摄像头 %s #####", ret == SUCCESS_LOCAL? "成功": "失败");

	pthread_mutex_unlock(&mutex);

	(*env)->ReleaseIntArrayElements(env, resolution, ptr_resolution, 0);
	(*env)->ReleaseIntArrayElements(env, ids, ptr_index, 0);

	if (name != NULL) {
		(*env)->ReleaseStringUTFChars(env, name, except_camera_name);
	}

    if (ret == SUCCESS_LOCAL) {
        InitWatermark("/system/ms_unicode_24.bin", IMG_WIDTH, IMG_HEIGHT);
        wm_enable = true;
    }

	return ret;
}

jint processCamera(JNIEnv* env, jobject thiz) {
    int ret;
    pthread_mutex_lock(&mutex);
	ret = readframeonce();
    pthread_mutex_unlock(&mutex);
    return ret;
}

void stopCamera(JNIEnv* env, jobject thiz) {
	pthread_mutex_lock(&mutex);
    cam_inited = false;

    wm_enable = false;
    UninitWatermark();

    LOGI("stopcapturing");
	stopcapturing();

	LOGI("uninitdevice");
	uninitdevice();

	LOGI("closedevice");
	closedevice();

	if (rgb){
		free(rgb);
	    rgb=NULL;
	}
	if (ybuf){
		free(ybuf);
		ybuf = NULL;
	}

	fd = -1;

	uninit_JPEG_turbo();

    LOGE("##### 反初始化摄像头 #####");

	pthread_mutex_unlock(&mutex);
}

static void mjpegToRGBA(const uint8_t *data, int length)
{
    read_JPEG_turbo(data, length, (uint8_t *)rgb);
}

void regenv(JNIEnv *env, jobject instance) {
	// TODO
// 保存全局JVM以便在子线程中使用
//	(*env)->GetJavaVM(env, &sg_jvm);
	// 不能直接赋值(g_obj = ojb)
	sg_obj = (*env)->NewGlobalRef(env, instance);

	if (init_module == 0) {
		pthread_mutex_init(&mutex, NULL);
		init_module++;
	}
}

jstring getPixelFormat(JNIEnv *env, jobject instance) {
	switch (img_pixelformat) {
		case V4L2_PIX_FMT_MJPEG:
			return (*env)->NewStringUTF(env, "MJPEG");
		case V4L2_PIX_FMT_YUYV:
			return (*env)->NewStringUTF(env, "YUYV");
		default:
			break;
	}
	return (*env)->NewStringUTF(env, "CLOSE");
}

jobject getUsbCameraInfo(JNIEnv *env, jobject instance) {
	jclass objectClass = (*env)->FindClass(env, "com/anyun/libusbcamera/UsbCameraInfo");
	jmethodID init1 = (*env)->GetMethodID(env, objectClass, "<init>",
										  "(ILjava/lang/String;ILjava/lang/String;Ljava/lang/String;[Lcom/anyun/libusbcamera/UsbCameraFormat;)V");

	jclass objectClass2 = (*env)->FindClass(env, "com/anyun/libusbcamera/UsbCameraFormat");
	jmethodID jidResultInfo = (*env)->GetMethodID(env, objectClass2, "<init>",
												  "(Ljava/lang/String;[[I)V");

	jobjectArray args = (*env)->NewObjectArray(env, CameraInfoNum, objectClass2, 0);

	jclass intArrCls = (*env)->FindClass(env, "[I");

	for (int i = 0; i < CameraInfoNum; ++i) {
		jobjectArray resArray = (*env)->NewObjectArray(env, CameraInfo[i].resolution_num, intArrCls, NULL);

		for (int j = 0; j < CameraInfo[i].resolution_num; j++) {
			jint buff1[2] = {CameraInfo[i].resolution[j][0], CameraInfo[i].resolution[j][1]};

			jintArray whArray = (*env)->NewIntArray(env, 2);
			(*env)->SetIntArrayRegion(env, whArray, 0, 2, buff1);

			(*env)->SetObjectArrayElement(env, resArray, j, whArray);

			(*env)->DeleteLocalRef(env, whArray);
		}
		jobject  son = (*env)->NewObject(env, objectClass2, jidResultInfo, (*env)->NewStringUTF(env, CameraInfo[i].name), resArray);
		(*env)->SetObjectArrayElement(env, args, i, son);

		(*env)->DeleteLocalRef(env, resArray);
		(*env)->DeleteLocalRef(env, son);
	}

	jobject ret = (*env)->NewObject(env, objectClass, init1,
									camera_index,
								 (*env)->NewStringUTF(env, camera_name[0] > 0? camera_name: "Unknown"),
									camera_version,
									(*env)->NewStringUTF(env, camera_true_version[0] > 0? camera_true_version: "Unknown"),
									(*env)->NewStringUTF(env, camera_sn[0] > 0? camera_sn: "Unknown"),
									args);
	(*env)->DeleteLocalRef(env, args);

	return ret;
}

jint getUsbCameraVersion(JNIEnv *env, jobject thiz) {
	// TODO: implement getUsbCameraVersion()
	return camera_version;
}

jstring getUsbCameraTrueVersion(JNIEnv *env, jobject thiz) {
	// TODO: implement getUsbCameraVersion()
	return (*env)->NewStringUTF(env, camera_true_version);
}

jstring getUsbCameraSn(JNIEnv *env, jobject thiz) {
	// TODO: implement getUsbCameraSn()
	return (*env)->NewStringUTF(env, camera_sn);
}

void enableWatermark(JNIEnv *env, jobject thiz, jboolean en, jstring font_)
{
	if (en && font_ != NULL) {
		const char *font = (*env)->GetStringUTFChars(env, font_, 0);
		InitWatermark(font, IMG_WIDTH, IMG_HEIGHT);
		(*env)->ReleaseStringUTFChars(env, font_, font);
		wm_enable = true;
	} else {
		UninitWatermark();
		wm_enable = false;
	}
}

void setWatermark(JNIEnv *env, jobject thiz, jint color, jint font_size, jint multiple, jobject texts)
{
	jclass cls_arraylist = (*env)->GetObjectClass(env, texts);

	if (cls_arraylist != NULL) {
		jmethodID arraylist_get = (*env)->GetMethodID(env, cls_arraylist,"get","(I)Ljava/lang/Object;");
		jmethodID arraylist_size = (*env)->GetMethodID(env, cls_arraylist,"size","()I");

		jint nums = (*env)->CallIntMethod(env, texts, arraylist_size);

		LOGI("Texts num = %d", nums);

		text_t *text_array = NULL;

		if (nums > 0) {
			text_array = malloc(nums * sizeof(text_t));
		}

		for (int i = 0; i < nums; ++i) {
			jobject obj_user = (*env)->CallObjectMethod(env, texts, arraylist_get, i);
			jclass cls_user = (*env)->GetObjectClass(env, obj_user);

			jfieldID idx = (*env)->GetFieldID(env, cls_user,"x","I");
			jfieldID idy = (*env)->GetFieldID(env, cls_user,"y","I");
			jfieldID idtext = (*env)->GetFieldID(env, cls_user,"text","Ljava/lang/String;");

			jint x = (*env)->GetIntField(env, obj_user, idx);
			jint y = (*env)->GetIntField(env, obj_user, idy);
			jstring value = (jstring )(*env)->GetObjectField(env, obj_user, idtext);
			const char *soc = (*env)->GetStringUTFChars(env, value, 0);
			LOGI("Text x = %d, y = %d, text = %s", x, y, soc);

			text_array[i].x = x;
			text_array[i].y = y;
			strcpy(text_array[i].text, soc);

			(*env)->ReleaseStringUTFChars(env, value, soc);
			(*env)->DeleteLocalRef(env, obj_user);
			(*env)->DeleteLocalRef(env, cls_user);
		}

		PrepareWatermark(color, font_size, multiple, nums, text_array);
		if (text_array != NULL) {
			free(text_array);
		}
	}

	LOGI("setWatermark end");

//	const char *school_temp = NULL;
//	const char *teacher_temp = NULL;
//	const char *student_temp = NULL;
//	const char *speed_temp = NULL;
//	const char *czh_temp = NULL;
//	const char *jwd_temp = NULL;
//	const char *date_temp = NULL;
//
//	if (school != NULL) {
//		school_temp = (*env)->GetStringUTFChars(env, school, 0);
//	}
//	if (teacher != NULL) {
//		teacher_temp = (*env)->GetStringUTFChars(env, teacher, 0);
//	}
//	if (student != NULL) {
//		student_temp = (*env)->GetStringUTFChars(env, student, 0);
//	}
//	if (speed != NULL) {
//		speed_temp = (*env)->GetStringUTFChars(env, speed, 0);
//	}
//	if (czh != NULL) {
//		czh_temp = (*env)->GetStringUTFChars(env, czh, 0);
//	}
//	if (jwd != NULL) {
//		jwd_temp = (*env)->GetStringUTFChars(env, jwd, 0);
//	}
//	if (date != NULL) {
//		date_temp = (*env)->GetStringUTFChars(env, date, 0);
//	}
//
//	PrepareWatermark(color, school_temp, teacher_temp, student_temp, speed_temp, czh_temp, jwd_temp, date_temp);
//
//	if (school != NULL) {
//		(*env)->ReleaseStringUTFChars(env, school, school_temp);
//	}
//	if (teacher != NULL) {
//		(*env)->ReleaseStringUTFChars(env, teacher, teacher_temp);
//	}
//	if (student != NULL) {
//		(*env)->ReleaseStringUTFChars(env, student, student_temp);
//	}
//	if (speed != NULL) {
//		(*env)->ReleaseStringUTFChars(env, speed, speed_temp);
//	}
//	if (czh != NULL) {
//		(*env)->ReleaseStringUTFChars(env, czh, czh_temp);
//	}
//	if (jwd != NULL) {
//		(*env)->ReleaseStringUTFChars(env, jwd, jwd_temp);
//	}
//	if (date != NULL) {
//		(*env)->ReleaseStringUTFChars(env, date, date_temp);
//	}
}

jboolean hardRebootUsbCamera(JNIEnv *env, jobject thiz)
{
    FILE *fp = fopen("/sys/devices/platform/soc/soc:ap-ahb/20200000.usb/mode_switch", "w");

    if (fp != NULL) {
        fwrite("device", 1, 6, fp);
        usleep(1000000);
        fflush(fp);
        fwrite("host", 1, 4, fp);
        fflush(fp);
        fclose(fp);
        return true;
    }

    return false;
}

static JNINativeMethod methods[] = {
	{"rgba", "(I[B)V", (void *)rgba},
	{"getPixelFormat", "()Ljava/lang/String;", (void *)getPixelFormat},
	{"pixeltobmp", "(Landroid/graphics/Bitmap;)V", (void *)pixeltobmp},
    {"prepareCamera", "([ILjava/lang/String;[IZ)I", (void *)prepareCamera},
	{"processCamera", "()I", (void *)processCamera},
	{"stopCamera", "()V", (void *)stopCamera},
	{"setenv", "()V", (void *)regenv},
	{"getUsbCameraInfo", "()Lcom/anyun/libusbcamera/UsbCameraInfo;", (void *)getUsbCameraInfo},
	{"getUsbCameraVersion", "()I", (void *)getUsbCameraVersion},
	{"getUsbCameraTrueVersion", "()Ljava/lang/String;", (void *)getUsbCameraTrueVersion},
	{"getUsbCameraSn", "()Ljava/lang/String;", (void *)getUsbCameraSn},
	{"enableWatermark", "(ZLjava/lang/String;)V", (void *)enableWatermark},
	{"setWatermark", "(IIILjava/util/ArrayList;)V", (void *)setWatermark},
    {"hardRebootUsbCamera", "()Z", (void *)hardRebootUsbCamera}
};

jint JNI_OnLoad(JavaVM *vm, void *reserved) {
	LOGI("JNI_OnLoad");

	sg_jvm = vm;

	if ((*sg_jvm)->GetEnv(sg_jvm, (void **) (&sg_jenv), JNI_VERSION_1_6) != JNI_OK) {
		LOGI("Env not got");
		return JNI_ERR;
	}

	jclass clz = (*sg_jenv)->FindClass(sg_jenv, "com/anyun/libusbcamera/UsbCamera");
	if (clz == NULL) {
		LOGI("目标类未找到");
		return JNI_ERR;
	}

	if ((*sg_jenv)->RegisterNatives(sg_jenv, clz, methods, LIBENC_ARRAY_ELEMS(methods))) {
		LOGI("methods not registered");
		return JNI_ERR;
	}

	return JNI_VERSION_1_6;
}

void JNI_OnUnload(JavaVM* vm, void* reserved) {
	LOGI("JNI_OnUnload");

	JNIEnv* env;

	if ((*vm)->GetEnv(vm, (void **) (&env), JNI_VERSION_1_6) != JNI_OK) {
		return;
	}

	jclass clz = (*env)->FindClass(env, "com/anyun/libusbcamera/UsbCamera");
	if (clz == NULL) {
		return;
	}

	(*env)->UnregisterNatives(env, clz);
}