#ifdef SUPPORT_MS_EXTENSIONS
#pragma bss_seg(".usb.data.bss")
#pragma data_seg(".usb.data")
#pragma code_seg(".usb.text")
#pragma const_seg(".usb.text.const")
#pragma str_literal_override(".usb.text.const")
#endif

/* #include "video/fb.h" */
#include "video.h"
#include "videobuf.h"
#include "device/device.h"
#include "system/init.h"
#include "system/task.h"
#include "system/malloc.h"
#include "event.h"
#include "ascii.h"
/* #include "asm/imc_driver.h" */
/* #include "asm/isp_dev.h" */

#include "debug.h"
#define LOG_TAG_CONST       USB
#define LOG_TAG             "[USB]"
#define LOG_ERROR_ENABLE
#define LOG_DEBUG_ENABLE
#define LOG_INFO_ENABLE
/* #define LOG_DUMP_ENABLE */
#define LOG_CLI_ENABLE



#define list_for_each_video_device(dev) \
	for (dev = video_dev_begin; dev < video_dev_end; dev++)


u32 video_buf_free_space(struct video_device *video)
{
    return videobuf_stream_free_space(&video->video_q);
}

void *video_buf_malloc(struct video_device *video, u32 size)
{
    struct videobuf_buffer *b;

    b = videobuf_stream_alloc(&video->video_q, size);
    if (!b) {
        return NULL;
    }
    b->len = size;

//	printf("video_buf: %x\n", b, b->data);

    return b->data;
}

void *video_buf_realloc(struct video_device *video, void *buf, int size)
{
    ASSERT(buf);
    struct videobuf_buffer *b = container_of(buf, struct videobuf_buffer, data);
    void *lbuf;
    ASSERT(b);


    b->len = size;
    lbuf = videobuf_stream_realloc(&video->video_q, b, size);
    if (lbuf == NULL) {
        return NULL;
    }

    return b->data;
}


void video_buf_free(struct video_device *video, void *buf)
{
    struct videobuf_buffer *b = container_of(buf, struct videobuf_buffer, data);

    if (buf == NULL) {
        return;
    }
    /* ASSERT(buf != NULL, "video_buf_free\n"); */

    videobuf_stream_free(&video->video_q, b);
}

int video_buf_query(struct video_device *video, struct videobuf_state *sta)
{
    return videobuf_query(&video->video_q, sta);
}

void *video_buf_ptr(void *buf)
{
    return buf;
}

u32 video_buf_size(void *buf)
{
    struct videobuf_buffer *b = container_of(buf, struct videobuf_buffer, data);

    return b->len;
}

int video_frame_cnt(struct video_device *video)
{
    return video->frame_cnt;
}


static void video_insert_end_frame(struct video_device *video)
{
    struct device_event e = {0};
    struct videobuf_buffer *b ;//= container_of(buf, struct videobuf_buffer, data);

    printf("=========finish: f=%d/%d t=%lu/%d i=%d\n", video->frame_cnt, video->stop_frame_cnt,
           jiffies, video->stop_time, video->insert_frame_cnt);
    b = videobuf_stream_alloc(&video->video_q, 8);
    if (b) {
        if (video->pixelformat & VIDEO_PIX_FMT_H264) {
            u32 flag = 0x18;
            b->len = 8;
            memcpy(b->data + 4, &flag, 4);

        } else if (video->pixelformat & VIDEO_PIX_FMT_JPEG) {
            u8 *buf = (u8 *)b->data;
            buf[0] = 0x56;
            buf[1] = 0x18;
            buf[2] = 0x57;
            buf[3] = 0x19;
            b->len = 8;
        }
        videobuf_stream_finish(&video->video_q, b);
#if 0
        if (video->time_base) {
            e.arg = "video_rec_time";
            e.value = 0;
            e.event = DEVICE_EVENT_CHANGE;
            device_event_notify(DEVICE_EVENT_FROM_VIDEO, &e);

        }
#endif
        video->frame_cnt = 0;
        video->insert_frame_cnt = 0;
        video->stop_frame_cnt = video->stop_frame_interval * video->fps.target_fps;
        /* video->stop_time = jiffies + msecs_to_jiffies(video->stop_frame_interval * 1000); */
        video->start_time = video->stop_time;
        video->stop_time = video->stop_time + msecs_to_jiffies(video->stop_frame_interval * 1000);

        if (video->dev_ops->start_I_frame) {
            video->dev_ops->start_I_frame(video);
        }
    }
    /* spin_lock(&video->ff.lock); */
    /* video->ff.o_frame_cnt++; */
    /* spin_unlock(&video->ff.lock); */
}

void video_buf_stream_finish(struct video_device *video, void *buf)
{
    struct videobuf_buffer *b = container_of(buf, struct videobuf_buffer, data);

    if (video->pixelformat & VIDEO_PIX_FMT_JPEG) {
        if (!video->frame_cnt) {
            video_buf_free(video, buf);
        } else {
            videobuf_stream_finish(&video->video_q, b);
        }
    } else {

        videobuf_stream_finish(&video->video_q, b);
    }


    video->frame_cnt++;

    /* if (video->time_base && (video->frame_cnt % video->fps.target_fps) == 0) { */
    /* e.arg = "video_rec_time"; */
    /* e.type = SYS_DEVICE_EVENT; */
    /* e.u.dev.value = video->frame_cnt / video->fps.target_fps; */
    /* e.u.dev.event = DEVICE_EVENT_CHANGE; */
    /* sys_event_notify(&e); */
    /* } */

    if (video->stop_skip_frame != 2) {
        spin_lock(&video->ff.lock);
        video->ff.o_frame_cnt++;
        spin_unlock(&video->ff.lock);
    }
}


void video_check_stream_finish(struct video_device *video)
{
    if (video->stop_time == 0) {
        return;
    }
    if (video->stop_skip_frame == 0) {
        if (video->pixelformat & VIDEO_PIX_FMT_H264) {
            if (time_after(jiffies, video->stop_time - 200)) {
                spin_lock(&video->ff.lock);
                video->stop_skip_frame = 1;
                spin_unlock(&video->ff.lock);

                /* if (video->frame_cnt < video->stop_frame_cnt && video->stop_frame_cnt - video->frame_cnt == 20) { */
                log_debug("force insert I frame %d/%d\n", video->frame_cnt, video->stop_frame_cnt);
                if (video->dev_ops->start_I_frame) {
                    video->dev_ops->start_I_frame(video);
                }
            }
        } else {
            if (time_after(jiffies, video->stop_time - 200)) {
                spin_lock(&video->ff.lock);
                video->stop_skip_frame = 1;
                spin_unlock(&video->ff.lock);
            }
        }
    }
#if 0
    //计算当前时间点应有的帧数
    int jiffies_interval = jiffies - video->start_time;
    int correct_frame_cnt = (jiffies_interval * 10) / (1000 / video->fps.target_fps);
    //当前时间的应当有的帧数与实际帧数相差太大,补帧
    if (correct_frame_cnt - (int)video->frame_cnt > 3) {
        int insert_frame_interval =  jiffies_to_msecs(jiffies - video->last_insert_time);
        int frame_interval = 1000 / video->fps.target_fps;
#if 0   //todo,打开这个会导致第三路录像慢放(多插帧)
        //如果帧差别过大，不考虑卡顿问题，一直补帧
        if (correct_frame_cnt - (int)video->frame_cnt >= 10) {
            video->insert_frame_cnt++;
            video->last_insert_time = jiffies;
            video_force_skip_frame(video);
        }
        //控制补帧间隔，避免连续补帧造成画面卡顿
        else
#endif
            if (insert_frame_interval > frame_interval * 3) {
                video->insert_frame_cnt++;
                video->last_insert_time = jiffies;
                video_force_skip_frame(video);
            }
    }
#endif

    if (video->time_base && (video->frame_cnt % (video->fps.target_fps * 10)) == 0) {
        //每10秒同步下UI计时
#if 0
        struct device_event e = {0};
        e.arg = "video_rec_time";
        e.value = video->frame_cnt / video->fps.target_fps;
        e.event = DEVICE_EVENT_CHANGE;
        device_event_notify(DEVICE_EVENT_FROM_VIDEO, &e);
#endif

    }

    if (time_after(jiffies, video->stop_time) || video->frame_cnt >= video->stop_frame_cnt) {
        if (video->stop_skip_frame == 1) {
            if (video->frame_cnt <= video->stop_frame_cnt) {
                spin_lock(&video->ff.lock);
                video->stop_skip_frame = 2;
                spin_unlock(&video->ff.lock);

                u32 need_skip_frame = video->stop_frame_cnt - video->frame_cnt + 1;
                while (need_skip_frame--) {
                    log_debug("force skip frame %d/%d\n", video->frame_cnt, video->stop_frame_cnt);
                    video_force_skip_frame(video);
                    /* spin_lock(&video->ff.lock); */
                    /* video->ff.o_frame_cnt++; */
                    /* spin_unlock(&video->ff.lock); */
                    /* need_skip_frame = video->stop_frame_cnt - video->frame_cnt; */
                }
                video_insert_end_frame(video);

                spin_lock(&video->ff.lock);
                video->stop_skip_frame = 0;
                spin_unlock(&video->ff.lock);
            } else {
                video_insert_end_frame(video);

                spin_lock(&video->ff.lock);
                video->stop_skip_frame = 0;
                spin_unlock(&video->ff.lock);
            }
            video_dev_fill_frames_reset(video);
        }
    }

}

int video_check_h264_manu_finish(struct video_device *video)
{
    if (video->stop_time == 0) {
        return 0;
    }

    /* log_d("frame %d/%d %d %d\n", jiffies, video->stop_time,video->frame_cnt,video->stop_frame_cnt); */
    if (time_after(jiffies, video->stop_time - 200)) {
        if (video->pixelformat & VIDEO_PIX_FMT_H264) {
            if (video->frame_cnt <= video->stop_frame_cnt && video->stop_frame_cnt - video->frame_cnt < 1) {

                video_insert_end_frame(video);
                return 1;
            }

        }
    }

    return 0;
}

static void __calculate_fill_interval(struct video_fill_frames *ff)
{
    int interval;

    if (ff->lost_frames == 0 || ff->fps_remain <= 1) {
        ff->fill_dly = 0;
        ff->interval = 0;
    } else {
        interval = (ff->fps_remain - 1) / ff->lost_frames;
        if (interval == 0) {
            ff->fill_dly = 0;
        } else if (ff->fill_dly > 0) {
            ff->fill_dly -= ff->interval - interval;
        } else {
            ff->fill_dly = interval;
        }
        ff->interval = interval;
    }
}


static void video_rec_check_fps(void *_video)
{
    struct video_device *video = (struct video_device *)_video;
    struct video_fill_frames *ff = &video->ff;
    struct video_dev_fps *fps = &video->fps;

    spin_lock(&ff->lock);

    if (video->dev_ops->adjust_fps) {
        video->dev_ops->adjust_fps(video, (void *)&fps->real_fps);
        if (fps->real_fps == 0) {
            fps->real_fps = fps->camera_fps;
        }
    }
    ff->reset_timer = 1;
    ff->fps_remain  = video->fps.real_fps;

    /* printf("time cnt : %d, target fps : %d, o frame count : %d, real fps : %d\n", ff->time_cnt, fps->target_fps, ff->o_frame_cnt, fps->real_fps); */
    if (fps->tlp_time) {
        ff->lost_frames = ++ff->time_cnt * 1000 / fps->tlp_time - ff->o_frame_cnt - 1000 / fps->tlp_time;
    } else {
        ff->lost_frames = ++ff->time_cnt * fps->target_fps - ff->o_frame_cnt - fps->real_fps;
    }
    /* if (ff->time_cnt >= 60) { */
    /* ff->time_cnt = 1; */
    /* ff->o_frame_cnt = 0; */
    /* } */

    __calculate_fill_interval(ff);

    spin_unlock(&ff->lock);

    /*printf("%ds: %d, %d\n", ff->time_cnt, ff->lost_frames, ff->interval);*/
}


static void video_rec_one_frame_timer(void *_video)
{
    struct video_device *video = (struct video_device *)_video;
    struct video_fill_frames *ff = &video->ff;

    spin_lock(&ff->lock);

    ff->lost_frames++;
    if (ff->fps_remain > 0) {
        ff->fps_remain--;
    }

    __calculate_fill_interval(ff);

    spin_unlock(&ff->lock);

    printf("lost: %d, %d\n", ff->lost_frames, ff->fill_dly);
}

/*
static void video_sec_timer(struct video_device *video)
{
    struct video_fill_frames *ff = &video->ff;

    if (ff->reset_timer) {
        sys_hi_timer_modify(ff->timer, 1000);
        ff->reset_timer = 0;
    }
}
*/

int video_dev_is_need_fill_frame(struct video_device *video)
{
    struct video_fill_frames *ff = &video->ff;
    int tmp;

    spin_lock(&ff->lock);

    tmp = ff->fill_dly - 1;
    if ((ff->lost_frames > 0) && (tmp <= 0)) {
        tmp = ff->lost_frames - 1;
        spin_unlock(&ff->lock);
        return tmp + 1;
    }

    spin_unlock(&ff->lock);

    return 0;
}
int video_dev_need_fill_frame(struct video_device *video)
{
#if 0
    struct video_fill_frames *ff = &video->ff;

#if 0
    if (ff->reset_timer) {
        ff->reset_timer = 0;
        sys_hi_timer_modify(ff->timer, 1000 - 16);
    }
#else
    if (ff->reset_timer && !ff->timer) {
        ff->timer = sys_hi_timer_add(video, video_rec_check_fps, 1000);
        ff->reset_timer = 0;
    }
#endif
    if (ff->o_frame_cnt <= 5) {
        return 0;
    }

    spin_lock(&ff->lock);

    if (ff->lost_frames > 0 && --ff->fill_dly <= 0) {
        ff->lost_frames--;
        __calculate_fill_interval(ff);

        if (ff->lost_frames > 100 * (ff->msg_post + 1)) {
            ff->msg_post ++;
            printf("ff->lost_frames:%d", ff->lost_frames);
            /* extern void video_write_err(u8 id, int drop_fcnt); */
            /* video_write_err(video->major, ff->lost_frames + 1); */
        }

        spin_unlock(&ff->lock);

        /* printf("\ndrop %d:%d %d\n", video->major, ff->lost_frames, ff->msg_post); */
        /* printf("fill: %d, %d, %d\n", ff->fps_remain, ff->lost_frames, ff->interval); */

        return ff->lost_frames + 1;
    } else {
        ff->msg_post = 0;
    }

    spin_unlock(&ff->lock);
#endif

    return 0;
}

void video_dev_reset_frame_interval_timer(struct video_device *video)
{
#if 0
    struct video_fill_frames *ff = &video->ff;
    u32 fps;

    spin_lock(&ff->lock);
    fps = video->fps.real_fps;
    spin_unlock(&ff->lock);

    if (ff->timer_one_frame) {
        /* sys_hi_timer_modify(ff->timer_one_frame, (1000 / video->fps.real_fps) * 3 / 2); */
        sys_hi_timer_modify(ff->timer_one_frame, (1000 / fps) * 3 / 2);
    }
#endif
}

void video_dev_real_frame_dec(struct video_device *video)
{
    struct video_fill_frames *ff = &video->ff;

    spin_lock(&ff->lock);

    if (ff->fps_remain > 0) {
        ff->fps_remain--;
    }

    spin_unlock(&ff->lock);
}

static void video_dev_fill_frames_init(struct video_device *video)
{
    struct video_fill_frames *ff = &video->ff;

    spin_lock_init(&ff->lock);

    video_rec_check_fps(video);

    /*ff->timer = sys_hi_timer_add(video, video_rec_check_fps, 2000);*/

    /*if (video->fps.real_fps == video->fps.camera_fps) {
        ff->timer_one_frame = sys_hi_timer_add(video, video_rec_one_frame_timer, 1000);
    }*/
}

void video_dev_fill_frames_reset(struct video_device *video)
{
    struct video_fill_frames *ff = &video->ff;
    spin_lock(&ff->lock);
    ff->time_cnt = 0;
    ff->o_frame_cnt = 0;
    ff->lost_frames = 0;
    spin_unlock(&ff->lock);
}

static void video_dev_fill_frames_uninit(struct video_device *video)
{
#if 0
    struct video_fill_frames *ff = &video->ff;

    if (ff->timer) {
        sys_hi_timer_del(ff->timer);
        ff->timer = 0;
    }

    if (ff->timer_one_frame) {
        sys_hi_timer_del(ff->timer_one_frame);
    }
#endif
}


static int video_dev_reqbufs(void *_video, struct video_reqbufs *b)
{
    struct video_device *video = (struct video_device *)_video;

    return videobuf_reqbufs(&video->video_q, b);
}


static int video_dev_qbuf(void *_video, struct video_buffer *b)
{
    struct video_device *video = (struct video_device *)_video;

    return videobuf_qbuf(&video->video_q, b);
}

static int video_dev_dqbuf(void *_video, struct video_buffer *b)
{
    struct video_device *video = (struct video_device *)_video;
    return videobuf_dqbuf(&video->video_q, b);
}



static void video_dev_dbuf_release(void *_video)
{
    struct video_device *video = (struct video_device *)_video;
    videobuf_streamoff(&video->video_q, 0);
    videobuf_queue_release(&video->video_q);
    video->mal_dbuf = 0;
}
static int video_dev_reqdbuf(void *_video, struct video_reqbufs *b)
{
    struct video_device *video = (struct video_device *)_video;
    int err = 0;
    u8 channel = 0;
    err = videobuf_reqbufs(&video->video_q, b);
    if (!err) {
        err = videobuf_streamon(&video->video_q, (u8 *)&channel);
        video->mal_dbuf = 1;
    }
    return err;
}
static int video_dev_idbuf(void *_video, struct video_buffer *b)
{
    struct video_device *video = (struct video_device *)_video;

    return videobuf_qbuf(&video->video_q, b);
}
static int video_dev_rdbuf(void *_video, struct video_buffer *b)
{
    struct video_device *video = (struct video_device *)_video;

    videobuf_dqbuf(&video->video_q, b);
    return 0;
}


static int video_ioctrl(void *_video, u32 cmd, void *arg)
{
    struct video_device *video = (struct video_device *)_video;

    if (video->dev_ops && video->dev_ops->ioctl) {
        return video->dev_ops->ioctl(video, cmd, (u32)arg);
    }

    return 0;
}


/*int video_subdev_request(struct video_endpoint *ep, int req, void *arg)
{
//	int err;
    struct video_endpoint *p;
    struct video_device *video = (struct video_device *)ep->parent;

    list_for_each_endpoint(p, video) {
        if (p == ep) {
            continue;
        }
        if (p->dev->ops->response) {
            p->dev->ops->response(p, req, arg);
        }
    }

    if (req == VIDREQ_IMAGE_CAPTURE_COMPLETED) {
        //video->icap->baddr = (u8 *)video_buf_ptr(arg);
        video->icap->size = (u32)arg;//video_buf_size(arg);
        [>puts("buf & size : \n");
        put_u32hex((u32)video->icap->baddr);
        put_u32hex(video->icap->size);<]
        os_sem_post(&video->sem);
    }

    return 0;
}*/


static int video_overlay(struct video_device *_video, unsigned int on)
{
    int err = -EINVAL;
    struct video_device *video = (struct video_device *)_video;

    if (video->dev_ops && video->dev_ops->overlay) {
        err = video->dev_ops->overlay(video, on);
    }

    return err;
}


static int video_streamon(struct video_device *_video, int channel)
{
    int err;
    struct video_device *video = (struct video_device *)_video;

    videobuf_streamon(&video->video_q, (u8 *)channel);

    if (video->streamon++) {
        return 0;
    }

    if (video->dev_ops && video->dev_ops->streamon) {
        err = video->dev_ops->streamon(video);
        if (err) {
            videobuf_streamoff(&video->video_q, channel);
            return err;
        }
    }
    if ((video->major == 0 && video->mijor == 0) || (video->major == 4 && video->mijor == 0)) {
        video->time_base = 1;
    }
    video->start_time = jiffies;
    video->stop_time = jiffies + msecs_to_jiffies(video->stop_frame_interval * 1000);

    printf("video:%x video->stop_time:%d", (u32)_video, video->stop_time);
    video_dev_fill_frames_init(video);

    return 0;
}


static int video_streamoff(void *_video, int index)
{
    int err;
    struct video_device *video = (struct video_device *)_video;

    if (--video->streamon == 0) {
        if (video->dev_ops && video->dev_ops->streamoff) {
            video->dev_ops->streamoff(video);
        }

        video_dev_fill_frames_uninit(video);
    }

    err = videobuf_streamoff(&video->video_q, index);
    if (err) {
        return err;
    }

    return 0;
}


static int video_remove_image_buf(struct video_device *video, void *arg)
{

    struct video_image_capture *icap = (struct video_image_capture *)arg;
    struct videobuf_buffer *b = NULL;

    b = container_of(video->icap->baddr, struct videobuf_buffer, data);
    ASSERT(video->icap->baddr != NULL, "video_remove_image_buf\n");

    videobuf_stream_free(&video->video_q, b);

    return 0;
}

static int video_image_capture(void *_video, struct video_image_capture *icap)
{
    int err = 0;
    struct video_device *video = (struct video_device *)_video;

    if (video->dev_ops && video->dev_ops->image_capture) {
        err = video->dev_ops->image_capture(video, icap);
    }

    return err;
}




static int video_init(const struct dev_node *node, void *_data)
{
    struct video_device_ops *ops;
    const struct video_platform_data *data = (const struct video_platform_data *)_data;

    list_for_each_video_device(ops) {
        if (!ASCII_StrCmp(ops->name, node->name, -1)) {
            if (ops->init) {
                ops->init(node->name, data);
            }
        }
    }

    return 0;
}

static bool video_online(const struct dev_node *node)
{
    struct video_device_ops *ops;

    list_for_each_video_device(ops) {
        if (!ASCII_StrCmp(ops->name, node->name, -1)) {
            if (ops->online) {
                return ops->online((void *)node->name);
            }
        }
    }

    return false;
}


static int video_open(const char *name, struct device **device, void *arg)
{
    int major = 0;
    int mijor = 0;
    struct video_device *video, *n;
    struct video_device_ops *ops;

    log_debug("video_device_open: %s\n", name);
    sscanf(name, "video%d.%d", &major, &mijor);

    video = (struct video_device *)zalloc(sizeof(*video));
    if (!video) {
        log_error("no mem\n");
        return -ENOMEM;
    }

    video->major = major;
    video->mijor = mijor;

    list_for_each_video_device(ops) {
        printf("ops->name:%s  name:%s\n", ops->name, name);
        if (!ASCII_StrCmp(ops->name, name, -1)) {
            int err = ops->open(video);
            if (err) {
                free(video);
                return err;
            }
            video->dev_ops = ops;
            break;
        }
    }

    *device = &video->device;
    (*device)->private_data = video;
    os_sem_create(&video->sem, 0);
    videobuf_queue_init(&video->video_q, 32, name);

    return 0;
}

static int video_set_fmt(struct video_device *video, struct video_format *f)
{
    if (video->dev_ops && video->dev_ops->set_fmt) {
        if (f->type == VIDEO_BUF_TYPE_VIDEO_CAPTURE) {
            video->pixelformat = f->pixelformat;
        }
        return video->dev_ops->set_fmt(video, f);
    }

    return -EINVAL;
}

static int video_write(struct device *device, void *data, u32 len, u32 addr)
{
    struct video_device *video = (struct video_device *)device->private_data;

    if (video->dev_ops && video->dev_ops->write) {
        if (len == video->dev_ops->write(video, data, len)) {
            return len;
        }
    }

    return 0;
}


static int video_close(struct device *device)
{
    struct video_device *video = (struct video_device *)device->private_data;

    log_debug("video dev close: video%d.%d\n", video->major, video->mijor);

    if (video->dev_ops && video->dev_ops->close) {
        video->dev_ops->close(video);
    }

    if (video->mal_dbuf) {
        video_dev_dbuf_release(video);
    } else {
        videobuf_queue_release(&video->video_q);
    }

    free(video);

    return 0;
}

static int video_ioctl(struct device *device, u32 cmd, u32 arg)
{
    int ret = 0;
    struct video_device *video = (struct video_device *)device->private_data;

    switch (cmd) {
    case VIDIOC_SET_FMT:
        ret = video_set_fmt(video, (struct video_format *)arg);
        log_debug("video_dev_set_fmt: %s\n", !ret ? "suss" : "err");
        break;
    case VIDIOC_OVERLAY:
        ret = video_overlay(video, arg);
        break;
    case VIDIOC_PLAY:
        ret = video_overlay(video, arg);
        break;
    case VIDIOC_STREAM_ON:
        ret = video_streamon(video, arg);
        log_debug("video_dev_streamon: %s\n", !ret ? "suss" : "err");
        break;
    case VIDIOC_STREAM_OFF:
        ret = video_streamoff(video, arg);
        break;
    case VIDIOC_IMAGE_CAPTURE:
        ret = video_image_capture(video, (struct video_image_capture *)arg);
        break;
    case VIDIOC_DEL_IMAGE:
        ret = video_remove_image_buf(video, (void *)arg);
        break;
    case VIDIOC_REQBUFS:
        ret = video_dev_reqbufs(video, (struct video_reqbufs *)arg);
        break;
    case VIDIOC_DQBUF:
        return video_dev_dqbuf(video, (struct video_buffer *)arg);
        break;
    case VIDIOC_QBUF:
        return video_dev_qbuf(video, (struct video_buffer *)arg);
        break;
    case VIDIOC_REQDBUF:
        ret = video_dev_reqdbuf(video, (struct video_reqbufs *)arg);
        break;
    case VIDIOC_QUERYBUF:
        video_buf_query(video, (struct videobuf_state *)arg);
        break;
    case VIDIOC_GET_FPS:
        ret = video_ioctrl(video, cmd, (void *)arg);
        if (ret == 0) {
            struct video_dev_fps *fps = (struct video_dev_fps *)arg;
        }
        break;
    case VIDIOC_SET_FPS:
        ret = video_ioctrl(video, cmd, (void *)arg);
        if (ret == 0) {
            struct video_dev_fps *fps = (struct video_dev_fps *)arg;
            if (video->streamon == 0) {
                memcpy(&video->fps, fps, sizeof(struct video_dev_fps));
            } else {
                struct video_fill_frames *ff = &video->ff;
                spin_lock(&ff->lock);
                video->fps.real_fps = fps->real_fps;
                spin_unlock(&ff->lock);
            }
        }
        log_debug("video_dev_set_fps: %s\n", !ret ? "suss" : "err");
        break;
    case VIDIOC_GET_FRAME_CNT:
        *(u32 *)arg = video->frame_cnt;
        break;
    case VIDIOC_SET_STOP_FRAME_INTERVAL:
        video->stop_frame_interval = arg;
        video->stop_frame_cnt = arg * video->fps.target_fps;
        printf("-------stop_frame_interval: %d %d %d\n", arg, video->stop_frame_interval, video->stop_frame_cnt);
        break;
    case VIDIOC_TRY_STOP_FRAME_INTERVAL:
        video->stop_frame_cnt = arg;
        break;
    case VIDIOC_START_IFREME:
        if (video->dev_ops->start_I_frame) {
            video->dev_ops->start_I_frame(video);
        }
        break;
    default:
        ret = video_ioctrl(video, cmd, (void *)arg);
        break;

    }

    if (ret) {
        printf("video_ioct: err = %d\n", ret);
    }

    return ret;
}


const struct device_operations video_dev_ops = {
    .init = video_init,
    .open = video_open,
    .write = video_write,
    .close = video_close,
    .ioctl = video_ioctl,
    .online = video_online,
};