/*
 * V4L2 video capture example
 * AUTHOT : Jacob Chen
 * DATA : 2018-02-25
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <getopt.h> /* getopt_long() */
#include <fcntl.h> /* low-level i/o */
#include <unistd.h>
#include <errno.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <dlfcn.h>
#include <signal.h>
#include <linux/videodev2.h>
#include "call_fun_ipc.h"
#include "drmDsp.h"
#include "rk_aiq_user_api_sysctl.h"
#include "rk_aiq_user_api_a3dlut.h"
// #include "rk_aiq_user_api_ablc.h"
#include "rk_aiq_user_api_imgproc.h"
#include "config.h"
#include <termios.h>

#define CLEAR(x) memset(&(x), 0, sizeof(x))
#define FMT_NUM_PLANES 1

#define BUFFER_COUNT 4
#define CAPTURE_RAW_PATH "/tmp"
#define CAPTURE_CNT_FILENAME "capture_cnt"

struct buffer {
        void *start;
        size_t length;
        int export_fd;
	int sequence;
};

static char out_file[255];
static char dev_name[255];
static int width = 640;
static int height = 480;
static int format = V4L2_PIX_FMT_NV12;
static int fd = -1;
static enum v4l2_buf_type buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
struct buffer *buffers;
static unsigned int n_buffers;
static int frame_count = -1;
FILE *fp = NULL;
static rk_aiq_sys_ctx_t* aiq_ctx = NULL;
static int silent = 0;
static int vop = 0;
static int rkaiq = 0;
static int writeFile = 0;
static int writeFileSync = 0;
static int pponeframe = 0;
static int hdrmode = 0;
static char sensor[64];

static int fd_pp_input = -1;
static int fd_isp_mp = -1;
struct buffer *buffers_mp;
static int outputCnt = 3;
static int skipCnt = 30;

static char yuv_dir_path[64];
static bool _is_yuv_dir_exist = false;
static int g_capture_yuv_num = 0x0;
static bool _is_capture_yuv;


#define DBG(...) do { if(!silent) printf(__VA_ARGS__); } while(0)
#define ERR(...) do { fprintf(stderr, __VA_ARGS__); } while (0)



static struct termios oldt;

//restore terminal settings
void restore_terminal_settings(void)
{
    // Apply saved settings
    tcsetattr(0, TCSANOW, &oldt);
}

//make terminal read 1 char at a time
void disable_terminal_return(void)
{
    struct termios newt;

    //save terminal settings
    tcgetattr(0, &oldt);
    //init new settings
    newt = oldt;
    //change settings
    newt.c_lflag &= ~(ICANON | ECHO);
    //apply settings
    tcsetattr(0, TCSANOW, &newt);

    //make sure settings will be restored when program ends
    atexit(restore_terminal_settings);
}

void test_imgproc(const rk_aiq_sys_ctx_t* ctx) {

   if (ctx == NULL) {
      return;
   }

   int key =getchar();
   printf("press key=[%c]\n",key);

    opMode_t mode;
    paRange_t range;
    expPwrLineFreq_t freq;
    rk_aiq_wb_scene_t scene;
    rk_aiq_wb_gain_t gain;
    unsigned int ct;
    antiFlickerMode_t flicker;
    switch (key)
    {
    case '0':
       rk_aiq_uapi_setExpMode(ctx, OP_MANUAL);
       printf("set exp manual\n");
       break;
    case '.':
       rk_aiq_uapi_setExpMode(ctx, OP_AUTO);
       printf("set exp auto\n");
       break;
    case '1':
       rk_aiq_uapi_getExpMode(ctx, &mode);
       printf("exp mode=%d\n",mode);
       break;
    case '2':
        range.min = 5.0f;
        range.max = 8.0f;
        rk_aiq_uapi_setExpGainRange(ctx, &range);
        printf("set gain range\n");
        break;
    case '3':
        rk_aiq_uapi_getExpGainRange(ctx, &range);
        printf("get gain range[%f,%f]\n",range.min,range.max);
        break;
    case '4':
        range.min = 10.0f;
        range.max = 30.0f;
        rk_aiq_uapi_setExpTimeRange(ctx, &range);
        printf("set time range\n");
      break;
    case '5':
        rk_aiq_uapi_getExpTimeRange(ctx, &range);
        printf("get time range[%f,%f]\n",range.min,range.max);
        break;
    case '6':
        rk_aiq_uapi_setExpPwrLineFreqMode(ctx, EXP_PWR_LINE_FREQ_50HZ);
        printf("setExpPwrLineFreqMode 50hz\n");
        break;
    case ',':
        rk_aiq_uapi_setExpPwrLineFreqMode(ctx, EXP_PWR_LINE_FREQ_60HZ);
        printf("setExpPwrLineFreqMode 60hz\n");
        break;
    case '7':
        rk_aiq_uapi_getExpPwrLineFreqMode(ctx, &freq);
        printf("getExpPwrLineFreqMode=%d\n",freq);
        break;
    case '8':
        rk_aiq_uapi_setWBMode(ctx, OP_MANUAL);
        printf("setWBMode manual\n");
        break;
    case '/':
        rk_aiq_uapi_setWBMode(ctx, OP_AUTO);
        printf("setWBMode auto\n");
        break;
    case '9':
        rk_aiq_uapi_getWBMode(ctx, &mode);
        printf("getWBMode=%d\n",mode);
        break;
    case 'a':
        rk_aiq_uapi_lockAWB(ctx);
        printf("lockAWB\n");
        break;
    case 'b':
        rk_aiq_uapi_unlockAWB(ctx);
        printf("unlockAWB\n");
        break;
    case 'c':
        rk_aiq_uapi_setMWBScene(ctx,RK_AIQ_WBCT_TWILIGHT);
        printf("setMWBScene\n");
        break;
    case 'd':
        rk_aiq_uapi_getMWBScene(ctx,&scene);
        printf("getMWBScene=%d\n",scene);
        break;
    case 'e':
        gain.rgain = 0.5f;
        gain.grgain = 0.5f;
        gain.gbgain = 0.5f;
        gain.bgain = 0.5f;
        rk_aiq_uapi_setMWBGain(ctx,&gain);
        printf("setMWBGain\n");
        break;
    case 'f':
        rk_aiq_uapi_getMWBGain(ctx,&gain);
        printf("getMWBGain=[%f %f %f %f]\n",gain.rgain,gain.grgain,gain.gbgain,gain.bgain);
        break;
    case 'g':
        ct = 5500;
        rk_aiq_uapi_setMWBCT(ctx, &ct);
        printf("setMWBCT\n");
        break;
    case 'h':
        rk_aiq_uapi_getMWBCT(ctx,&ct);
        printf("getMWBCT=[%d]\n",ct);
        break;
    case 'i':
        rk_aiq_uapi_setAntiFlickerMode(ctx,ANTIFLICKER_NORMAL_MODE);
        printf("setAntiFlickerMode normal\n");
        break;
    case 'j':
        rk_aiq_uapi_setAntiFlickerMode(ctx,ANTIFLICKER_AUTO_MODE);
        printf("setAntiFlickerMode auto\n");
        break;
    case 'k':
        rk_aiq_uapi_getAntiFlickerMode(ctx, &flicker);
        printf("getAntiFlickerMode=%d\n",flicker);
        break;
    case 'l':
        rk_aiq_uapi_setSaturation(ctx, 50);
        printf("setSaturation\n");
        break;
    case 'm':
        unsigned int level1;
        rk_aiq_uapi_getSaturation(ctx, &level1);
        printf("getSaturation=%f\n",level1);
        break;
    case 'n':
        rk_aiq_uapi_setCrSuppsn(ctx, 50.0);
        printf("setCrSuppsn\n");
        break;
    case 'o':
        unsigned int level2;
        rk_aiq_uapi_getCrSuppsn(ctx, &level2);
        printf("getCrSuppsn=%d\n",level2);
        break;
    case 'p':
        rk_aiq_uapi_setHDRMode(ctx, OP_AUTO);
        printf("setHDRMode\n");
        break;
    case 'q':
        rk_aiq_uapi_setHDRMode(ctx, OP_MANUAL);
        printf("setHDRMode\n");
        break;
    case 'r':
        rk_aiq_uapi_getHDRMode(ctx, &mode);
        printf("getHDRMode=%d\n",mode);
        break;
    case 's':
        rk_aiq_uapi_setNRMode(ctx, OP_MANUAL);
        printf("setNRMode\n");
        break;
    case 't':
        rk_aiq_uapi_getNRMode(ctx, &mode);
        printf("getNRMode=%d\n",mode);
        break;
     case 'u':
        rk_aiq_uapi_setDhzMode(ctx, OP_MANUAL);
        printf("setDhzMode\n");
        break;
    case 'v':
        rk_aiq_uapi_getDhzMode(ctx, &mode);
        printf("getDhzMode=%d\n",mode);
        break;
    default:
        break;
    }
}

static void errno_exit(const char *s)
{
        ERR("%s error %d, %s\n", s, errno, strerror(errno));
        exit(EXIT_FAILURE);
}

static int xioctl(int fh, int request, void *arg)
{
        int r;
        do {
                r = ioctl(fh, request, arg);
        } while (-1 == r && EINTR == errno);
        return r;
}

bool get_value_from_file(const char* path, int* value)
{
    char buffer[8] = {0};
    int fp;

    fp = open(path, O_RDONLY | O_SYNC);
    if (fp) {
	if (read(fp, buffer, sizeof(buffer)) <= 0)
	    printf("%s read %s failed!\n", __func__, path);
	else
	    *value = atoi(buffer);
	close(fp);
	return true;
    }

    return false;
}

static int write_yuv_to_file(const void *p,
			     int size, int sequence)
{
	char file_name[64] = {0};

	snprintf(file_name, sizeof(file_name),
			"%s/frame%d.yuv",
			yuv_dir_path,
			sequence);
	fp = fopen(file_name, "wb+");
	if (fp == NULL) {
		ERR("fopen yuv file %s failed!\n", file_name);
		return -1;
	}

	fwrite(p, size, 1, fp);
	fflush(fp);

	if (fp) {
		fclose(fp);
		fp = NULL;
	}

        for (int i = 0; i < g_capture_yuv_num; i++)
            printf("<");

	printf("\n");
	// printf("write frame%d yuv\n", sequence);

	return 0;
}

static int creat_yuv_dir(const char* path)
{
	time_t now;
	struct tm* timenow;

	if (!path)
		return -1;

	time(&now);
	timenow = localtime(&now);
	snprintf(yuv_dir_path, sizeof(yuv_dir_path),
			"%s/yuv_%04d-%02d-%02d_%02d-%02d-%02d",
			path,
			timenow->tm_year + 1900,
			timenow->tm_mon + 1,
			timenow->tm_mday,
			timenow->tm_hour,
			timenow->tm_min,
			timenow->tm_sec);

	// printf("mkdir %s for capturing yuv!\n", yuv_dir_path);

	if(mkdir(yuv_dir_path, 0755) < 0) {
		printf("mkdir %s error!!!\n", yuv_dir_path);
		return -1;
	}

	_is_yuv_dir_exist = true;

	return 0;
}

static void process_image(const void *p, int sequence,int size)
{
	if (fp && sequence >= skipCnt && outputCnt-- > 0) {
		printf(">\n");
		fwrite(p, size, 1, fp);
		fflush(fp);
	} else if (writeFileSync) {
		int ret = 0;

		if (!_is_capture_yuv) {
		    char file_name[32] = {0};

		    snprintf(file_name, sizeof(file_name), "%s/%s",
			     CAPTURE_RAW_PATH, CAPTURE_CNT_FILENAME);
		    get_value_from_file(file_name, &g_capture_yuv_num);

		    if (g_capture_yuv_num > 0)
			_is_capture_yuv = true;

		    if (sequence != 0)
			return;
		}

		if (_is_capture_yuv) {
		    if (!_is_yuv_dir_exist) {
		        creat_yuv_dir(CAPTURE_RAW_PATH);
		    }

		    if (_is_yuv_dir_exist) {
			write_yuv_to_file(p, size, sequence);
		    }

		    if (--g_capture_yuv_num == 0) {
			_is_capture_yuv = false;
			_is_yuv_dir_exist = false;
		    }
		}
	}
}

static int read_frame()
{
        struct v4l2_buffer buf;
        int i, bytesused;

        CLEAR(buf);

        buf.type = buf_type;
        buf.memory = V4L2_MEMORY_MMAP;

        struct v4l2_plane planes[FMT_NUM_PLANES];
        if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type) {
            buf.m.planes = planes;
            buf.length = FMT_NUM_PLANES;
        }

        if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf))
                errno_exit("VIDIOC_DQBUF");

        i = buf.index;

        if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type)
            bytesused = buf.m.planes[0].bytesused;
        else
            bytesused = buf.bytesused;

	if (vop) {
	    drmDspFrame(width, height, buffers[i].start, DRM_FORMAT_NV12);
	}

	process_image(buffers[i].start,  buf.sequence, bytesused);

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

        return 1;
}

static int read_frame_pp_oneframe()
{
        struct v4l2_buffer buf;
        struct v4l2_buffer buf_pp;
        int i,ii, bytesused;
        static int first_time = 1;

        CLEAR(buf);
        // dq one buf from isp mp
        printf("------ dq 1 from isp mp --------------\n");
        buf.type = buf_type;
        buf.memory = V4L2_MEMORY_MMAP;

        struct v4l2_plane planes[FMT_NUM_PLANES];
        if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type) {
            buf.m.planes = planes;
            buf.length = FMT_NUM_PLANES;
        }

        if (-1 == xioctl(fd_isp_mp, VIDIOC_DQBUF, &buf))
                errno_exit("VIDIOC_DQBUF");

        i = buf.index;

        if (first_time ) {
            printf("------ dq 2 from isp mp --------------\n");
            if (-1 == xioctl(fd_isp_mp, VIDIOC_DQBUF, &buf))
                    errno_exit("VIDIOC_DQBUF");

            ii = buf.index;
        }

        if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type)
            bytesused = buf.m.planes[0].bytesused;
        else
            bytesused = buf.bytesused;

        // queue to ispp input
        printf("------ queue 1 index %d to ispp input --------------\n", i);
        CLEAR(buf_pp);
        buf_pp.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
        buf_pp.memory = V4L2_MEMORY_DMABUF;
        buf_pp.index = i;

        struct v4l2_plane planes_pp[FMT_NUM_PLANES];
        memset(planes_pp, 0, sizeof(planes_pp));
        buf_pp.m.planes = planes_pp;
        buf_pp.length = FMT_NUM_PLANES;
        buf_pp.m.planes[0].m.fd = buffers_mp[i].export_fd;

        if (-1 == xioctl(fd_pp_input, VIDIOC_QBUF, &buf_pp))
                errno_exit("VIDIOC_QBUF");

        if (first_time ) {
            printf("------ queue 2 index %d to ispp input --------------\n", ii);
            buf_pp.index = ii;
            buf_pp.m.planes[0].m.fd = buffers_mp[ii].export_fd;
            if (-1 == xioctl(fd_pp_input, VIDIOC_QBUF, &buf_pp))
                    errno_exit("VIDIOC_QBUF");
        }
        // read frame from ispp sharp/scale
        printf("------ readframe from output --------------\n");
        read_frame();
        // dq from pp input
        printf("------ dq 1 from ispp input--------------\n");
        if (-1 == xioctl(fd_pp_input, VIDIOC_DQBUF, &buf_pp))
                errno_exit("VIDIOC_DQBUF");
        // queue back to mp
        printf("------ queue 1 index %d back to isp mp--------------\n", buf_pp.index);
        buf.index = buf_pp.index;
        if (-1 == xioctl(fd_isp_mp, VIDIOC_QBUF, &buf))
            errno_exit("VIDIOC_QBUF");

        first_time = 0;
        return 1;
}

static void mainloop(void)
{
    bool loop_inf = frame_count == -1 ? true : false;

    while (loop_inf || (frame_count-- > 0)) {
        if (pponeframe)
            read_frame_pp_oneframe();
        else
            read_frame();
    }
}

static void stop_capturing(void)
{
        enum v4l2_buf_type type;

        type = buf_type;
        if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
            errno_exit("VIDIOC_STREAMOFF");
}

static void stop_capturing_pp_oneframe(void)
{
        enum v4l2_buf_type type;

        type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
        if (-1 == xioctl(fd_pp_input, VIDIOC_STREAMOFF, &type))
            errno_exit("VIDIOC_STREAMOFF ppinput");
        type = buf_type;
        if (-1 == xioctl(fd_isp_mp, VIDIOC_STREAMOFF, &type))
            errno_exit("VIDIOC_STREAMOFF ispmp");
}

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

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

                CLEAR(buf);
                buf.type = buf_type;
                buf.memory = V4L2_MEMORY_MMAP;
                buf.index = i;

                if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type) {
                    struct v4l2_plane planes[FMT_NUM_PLANES];

                    buf.m.planes = planes;
                    buf.length = FMT_NUM_PLANES;
                }
                if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
                        errno_exit("VIDIOC_QBUF");
        }
        type = buf_type;
        printf("-------- stream on output -------------\n");
        if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
                errno_exit("VIDIOC_STREAMON");
}

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

        type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
        printf("-------- stream on pp input -------------\n");
        if (-1 == xioctl(fd_pp_input, VIDIOC_STREAMON, &type))
                errno_exit("VIDIOC_STREAMON pp input");

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

                CLEAR(buf);
                buf.type = buf_type;
                buf.memory = V4L2_MEMORY_MMAP;
                buf.index = i;

                if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type) {
                    struct v4l2_plane planes[FMT_NUM_PLANES];

                    buf.m.planes = planes;
                    buf.length = FMT_NUM_PLANES;
                }
                if (-1 == xioctl(fd_isp_mp, VIDIOC_QBUF, &buf))
                        errno_exit("VIDIOC_QBUF");
        }
        printf("-------- stream on isp mp -------------\n");
        if (-1 == xioctl(fd_isp_mp, VIDIOC_STREAMON, &type))
                errno_exit("VIDIOC_STREAMON ispmp");
}


static void uninit_device(void)
{
        unsigned int i;

        for (i = 0; i < n_buffers; ++i) {
            if (-1 == munmap(buffers[i].start, buffers[i].length))
                    errno_exit("munmap");

            close(buffers[i].export_fd);
        }

        free(buffers);
}

static void uninit_device_pp_oneframe(void)
{
        unsigned int i;

        for (i = 0; i < n_buffers; ++i) {
            if (-1 == munmap(buffers_mp[i].start, buffers_mp[i].length))
                    errno_exit("munmap");

            close(buffers_mp[i].export_fd);
        }

        free(buffers_mp);
}

static void init_mmap(int pp_onframe)
{
        struct v4l2_requestbuffers req;
        int fd_tmp = -1;

        CLEAR(req);

        if (pp_onframe)
            fd_tmp = fd_isp_mp ;
        else
            fd_tmp = fd;

        req.count = BUFFER_COUNT;
        req.type = buf_type;
        req.memory = V4L2_MEMORY_MMAP;

        struct buffer *tmp_buffers = NULL;

        if (-1 == xioctl(fd_tmp, VIDIOC_REQBUFS, &req)) {
                if (EINVAL == errno) {
                        ERR("%s does not support "
                                 "memory mapping\n", dev_name);
                        exit(EXIT_FAILURE);
                } else {
                        errno_exit("VIDIOC_REQBUFS");
                }
        }

        if (req.count < 2) {
                ERR("Insufficient buffer memory on %s\n",
                         dev_name);
                exit(EXIT_FAILURE);
        }

        tmp_buffers = (struct buffer*)calloc(req.count, sizeof(struct buffer));

        if (!tmp_buffers) {
                ERR("Out of memory\n");
                exit(EXIT_FAILURE);
        }

        if (pp_onframe)
            buffers_mp = tmp_buffers;
        else
            buffers = tmp_buffers;

        for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
                struct v4l2_buffer buf;
                struct v4l2_plane planes[FMT_NUM_PLANES];
                CLEAR(buf);
                CLEAR(planes);

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

                if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type) {
                    buf.m.planes = planes;
                    buf.length = FMT_NUM_PLANES;
                }

                if (-1 == xioctl(fd_tmp, VIDIOC_QUERYBUF, &buf))
                        errno_exit("VIDIOC_QUERYBUF");

                if (V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE == buf_type) {
                    tmp_buffers[n_buffers].length = buf.m.planes[0].length;
                    tmp_buffers[n_buffers].start =
                        mmap(NULL /* start anywhere */,
                              buf.m.planes[0].length,
                              PROT_READ | PROT_WRITE /* required */,
                              MAP_SHARED /* recommended */,
                              fd_tmp, buf.m.planes[0].m.mem_offset);
                } else {
                    tmp_buffers[n_buffers].length = buf.length;
                    tmp_buffers[n_buffers].start =
                        mmap(NULL /* start anywhere */,
                              buf.length,
                              PROT_READ | PROT_WRITE /* required */,
                              MAP_SHARED /* recommended */,
                              fd_tmp, buf.m.offset);
                }

                if (MAP_FAILED == tmp_buffers[n_buffers].start)
                        errno_exit("mmap");

                // export buf dma fd
                struct v4l2_exportbuffer expbuf;
                xcam_mem_clear (expbuf);
                expbuf.type = buf_type;
                expbuf.index = n_buffers;
                expbuf.flags = O_CLOEXEC;
                if (xioctl(fd_tmp, VIDIOC_EXPBUF, &expbuf) < 0) {
                    errno_exit("get dma buf failed\n");
                } else {
                    printf("get dma buf(%d)-fd: %d\n", n_buffers, expbuf.fd);
                }
                tmp_buffers[n_buffers].export_fd = expbuf.fd;
        }
}

static void init_input_dmabuf_oneframe(void) {
        struct v4l2_requestbuffers req;

        CLEAR(req);

        printf("-------- request pp input buffer -------------\n");
        req.count = BUFFER_COUNT;
        req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
        req.memory = V4L2_MEMORY_DMABUF;

        if (-1 == xioctl(fd_pp_input, VIDIOC_REQBUFS, &req)) {
                if (EINVAL == errno) {
                        ERR("does not support "
                                 "DMABUF\n");
                        exit(EXIT_FAILURE);
                } else {
                        errno_exit("VIDIOC_REQBUFS");
                }
        }

        if (req.count < 2) {
                ERR("Insufficient buffer memory on %s\n",
                         dev_name);
                exit(EXIT_FAILURE);
        }
    printf("-------- request isp mp buffer -------------\n");
    init_mmap(true);
}

static void init_device(void)
{
        struct v4l2_capability cap;
        struct v4l2_format fmt;

        if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
                if (EINVAL == errno) {
                        ERR("%s is no V4L2 device\n",
                                 dev_name);
                        exit(EXIT_FAILURE);
                } else {
                        errno_exit("VIDIOC_QUERYCAP");
                }
        }

        if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
                !(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)) {
            ERR("%s is not a video capture device, capabilities: %x\n",
                         dev_name, cap.capabilities);
                exit(EXIT_FAILURE);
        }

        if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
                ERR("%s does not support streaming i/o\n",
                    dev_name);
                exit(EXIT_FAILURE);
        }

        if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)
            buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        else if (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE_MPLANE)
            buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;

        CLEAR(fmt);
        fmt.type = buf_type;
        fmt.fmt.pix.width = width;
        fmt.fmt.pix.height = height;
        fmt.fmt.pix.pixelformat = format;
        fmt.fmt.pix.field = V4L2_FIELD_INTERLACED;

        if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
                errno_exit("VIDIOC_S_FMT");

	init_mmap(false);
}

static void init_device_pp_oneframe(void)
{
    // TODO, set format and link, now do with setup_link.sh
    init_input_dmabuf_oneframe();
}

static void close_device(void)
{
        if (-1 == close(fd))
                errno_exit("close");

        fd = -1;
}

static void open_device(void)
{
        printf("-------- open output dev_name -------------\n");
        fd = open(dev_name, O_RDWR /* required */ /*| O_NONBLOCK*/, 0);

        if (-1 == fd) {
                ERR("Cannot open '%s': %d, %s\n",
                         dev_name, errno, strerror(errno));
                exit(EXIT_FAILURE);
        }
}

static void close_device_pp_oneframe(void)
{
        if (-1 == close(fd_pp_input))
                errno_exit("close");

        fd_pp_input = -1;

        if (-1 == close(fd_isp_mp))
                errno_exit("close");

        fd_isp_mp = -1;
}

static void open_device_pp_oneframe(void)
{
        printf("-------- open pp input(video13) -------------\n");
        fd_pp_input = open("/dev/video13", O_RDWR /* required */ /*| O_NONBLOCK*/, 0);

        if (-1 == fd_pp_input) {
                ERR("Cannot open '%s': %d, %s\n",
                         dev_name, errno, strerror(errno));
                exit(EXIT_FAILURE);
        }

        printf("-------- open isp mp(video0) -------------\n");
        fd_isp_mp = open("/dev/video0", O_RDWR /* required */ /*| O_NONBLOCK*/, 0);

        if (-1 == fd_isp_mp ) {
                ERR("Cannot open '%s': %d, %s\n",
                         dev_name, errno, strerror(errno));
                exit(EXIT_FAILURE);
        }
}

static void uninit_device_pp_onframe(void)
{
        unsigned int i;

        for (i = 0; i < n_buffers; ++i) {
                if (-1 == munmap(buffers_mp[i].start, buffers_mp[i].length))
                        errno_exit("munmap");
                close(buffers_mp[i].export_fd);
        }

        free(buffers_mp);
}

void parse_args(int argc, char **argv)
{
   int c;
   int digit_optind = 0;

   while (1) {
       int this_option_optind = optind ? optind : 1;
       int option_index = 0;
       static struct option long_options[] = {
           {"width",    required_argument, 0, 'w' },
           {"height",   required_argument, 0, 'h' },
           {"format",   required_argument, 0, 'f' },
           {"device",   required_argument, 0, 'd' },
           {"stream-to",   required_argument, 0, 'o' },
           {"stream-count",   required_argument, 0, 'n' },
           {"stream-skip",   required_argument, 0, 'k' },
           {"count",    required_argument, 0, 'c' },
           {"help",     no_argument,       0, 'p' },
           {"silent",   no_argument,       0, 's' },
           {"vop",   no_argument,       0, 'v' },
           {"rkaiq",   no_argument,       0, 'r' },
           {"pponeframe",   no_argument,       0, 'm' },
           {"hdr",   no_argument,       0, 'a' },
           {"sensor",   required_argument,       0, 'b' },
           {"sync-to-raw", no_argument, 0, 'e' },
           {0,          0,                 0,  0  }
       };

       //c = getopt_long(argc, argv, "w:h:f:i:d:o:c:ps",
       c = getopt_long(argc, argv, "w:h:f:i:d:o:c:n:k:m:pse",
           long_options, &option_index);
       if (c == -1)
           break;

       switch (c) {
       case 'c':
           frame_count = atoi(optarg);
           break;
       case 'w':
           width = atoi(optarg);
           break;
       case 'h':
           height = atoi(optarg);
           break;
       case 'f':
           format = v4l2_fourcc(optarg[0], optarg[1], optarg[2], optarg[3]);
           break;
       case 'd':
           strcpy(dev_name, optarg);
           break;
       case 'o':
           strcpy(out_file, optarg);
           writeFile = 1;
	   break;
       case 'n':
           outputCnt = atoi(optarg);
	   break;
       case 'k':
           skipCnt = atoi(optarg);
	   break;
       case 's':
           silent = 1;
           break;
       case 'v':
           vop = 1;
           break;
       case 'r':
           rkaiq = 1;
           break;
       case 'm':
           pponeframe = 1;
           break;
       case 'a':
           hdrmode = 1;
           break;
       case 'b':
           strcpy(sensor, optarg);
           break;
       case 'e':
	   writeFileSync = 1;
           break;
       case '?':
       case 'p':
           ERR("Usage: %s to capture rkisp1 frames\n"
                  "         --width,  default 640,             optional, width of image\n"
                  "         --height, default 480,             optional, height of image\n"
                  "         --format, default NV12,            optional, fourcc of format\n"
                  "         --count,  default 1000,            optional, how many frames to capture\n"
                  "         --device,                          required, path of video device\n"
                  "         --stream-to,                       optional, output file path, if <file> is '-', then the data is written to stdout\n"
                  "         --stream-count, default 3	       optional, how many frames to write files\n"
                  "         --stream-skip, default 30	       optional, how many frames to skip befor writing file\n"
                  "         --vop,                             optional, drm display\n"
                  "         --rkaiq,                           optional, auto image quality\n",
                  "         --silent,                          optional, subpress debug log\n",
                  "         --pponeframe,                      optional, pp oneframe readback mode\n",
                  "         --hdr,                             optional, hdr mode\n",
                  "         --sensor,  default os04a10,        optional, sensor names\n",
                  "         --sync-to-raw,		       optional, write yuv files in sync with raw\n",
                  argv[0]);
           exit(-1);

       default:
           ERR("?? getopt returned character code 0%o ??\n", c);
       }
   }

   if (strlen(dev_name) == 0) {
        ERR("arguments --output and --device are required\n");
        exit(-1);
   }

}

static void deinit()
{
    stop_capturing();
    if (pponeframe)
        stop_capturing_pp_oneframe();
	if (aiq_ctx) {
        printf("-------- stop aiq -------------\n");
		rk_aiq_uapi_sysctl_stop(aiq_ctx, false);
        printf("-------- deinit aiq -------------\n");
		rk_aiq_uapi_sysctl_deinit(aiq_ctx);
        printf("-------- deinit aiq end -------------\n");
	}

    //stop_capturing();
    uninit_device();
    if (pponeframe)
        uninit_device_pp_oneframe();
    close_device();
    if (pponeframe)
        close_device_pp_oneframe();

    if (fp)
        fclose(fp);
}
static void signal_handle(int signo)
{
    printf("force exit signo %d !!!\n",signo);
    deinit();
    exit(0);
}
static void main_exit(void)
{
    printf("client %s\n", __func__);
    call_fun_ipc_client_deinit();
}

void signal_crash_handler(int sig)
{
    exit(-1);
}

void signal_exit_handler(int sig)
{
    exit(0);
}

void* test_thread(void* args) {
    pthread_detach (pthread_self());
    disable_terminal_return();
    printf("begin test imgproc\n");
    while(1) {
        test_imgproc(aiq_ctx);
    }
    printf("end test imgproc\n");
    restore_terminal_settings();
}


int main(int argc, char **argv)
{
    signal(SIGINT, signal_handle);
    atexit(main_exit);
    signal(SIGTERM, signal_exit_handler);
    //signal(SIGINT, signal_exit_handler);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGBUS, signal_crash_handler);
    signal(SIGSEGV, signal_crash_handler);
    signal(SIGFPE, signal_crash_handler);
    signal(SIGABRT, signal_crash_handler);
    strcpy(sensor, "os04a10");
    parse_args(argc, argv);

    printf("-------- open output dev -------------\n");
    open_device();
    if (pponeframe)
        open_device_pp_oneframe();
    init_device();
    if (pponeframe)
        init_device_pp_oneframe();
    if (writeFile) {
        fp = fopen(out_file, "w+");
        if (fp == NULL) {
            ERR("fopen output file %s failed!\n", out_file);
            exit(-1);
        }
    }

    const char* sns_entity_name = NULL;
    rk_aiq_working_mode_t work_mode = RK_AIQ_WORKING_MODE_NORMAL;

    if (strcasecmp(sensor, "ov4689") == 0) {
        if (hdrmode)
            work_mode = RK_AIQ_WORKING_MODE_ISP_HDR3;
        sns_entity_name = "m01_f_ov4689 1-0036";
    } else if (strcasecmp(sensor, "os04a10") == 0) {
        if (hdrmode)
            work_mode = RK_AIQ_WORKING_MODE_ISP_HDR2;
        sns_entity_name = "m01_f_os04a10 1-0036";
    } else if (strcasecmp(sensor, "gc4c33") == 0) {
        if (hdrmode)
            work_mode = RK_AIQ_WORKING_MODE_ISP_HDR2;
        sns_entity_name = "m01_f_gc4c33 1-0029";
    } else if (strcasecmp(sensor, "imx347") == 0) {
        if (hdrmode)
            work_mode = RK_AIQ_WORKING_MODE_ISP_HDR2;
        sns_entity_name = "m01_f_imx347 1-0037";
    }

    printf("sns_entity_name %s\n", sns_entity_name);
	if (rkaiq) {
        printf("+++++call_fun_ipc_client_init\n");
        //int r = 0xFEFEFEFE;
      //  while (r == 0xFEFEFEFE) {
        call_fun_ipc_client_init(DBUS_NAME, DBUS_IF, DBUS_PATH, SHARE_PATH, 1);
         //   usleep(1000*1000);
        //    printf("=======call_fun_ipc_client_init, r=0x%x\n",r);
      //  }

		aiq_ctx = rk_aiq_uapi_sysctl_init(sns_entity_name,NULL, NULL, NULL);

		if (aiq_ctx) {
            printf("-------- init mipi tx/rx -------------\n");
			XCamReturn ret = rk_aiq_uapi_sysctl_prepare(aiq_ctx, width, height, work_mode);
			if (ret != XCAM_RETURN_NO_ERROR)
				ERR("rk_aiq_uapi_sysctl_prepare failed: %d\n", ret);
			else {
                /* printf("-------- stream on mipi tx/rx -------------\n"); */
				/* ret = rk_aiq_uapi_sysctl_start(aiq_ctx ); */
				start_capturing();
                if (pponeframe)
                    start_capturing_pp_oneframe();
                printf("-------- stream on mipi tx/rx -------------\n");
				ret = rk_aiq_uapi_sysctl_start(aiq_ctx);
                printf("-------------stream on mipi end\n");
			}

			if (vop) {
				if (initDrmDsp() < 0) {
					printf("DRM display init failed\n");
					exit(0);
				}
			}

			usleep(500 * 1000);
		}
	} else {
		if (vop) {
			if (initDrmDsp() < 0) {
				printf("DRM display init failed\n");
				exit(0);
			}
		}

		usleep(500 * 1000);

		start_capturing();
        if (pponeframe)
            start_capturing_pp_oneframe();
	}
#if ENABLE_TEST
    pthread_t tid;
    pthread_create(&tid, NULL, (void*)test_thread, NULL);
#endif
    mainloop();

    deinit();

    return 0;
}