/*
 * Copyright (C) 2019 Rockchip Electronics Co., Ltd.
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL), available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include "uvc_video.h"
#include "uvc-gadget.h"
#include "yuv.h"
#include "mpi_enc.h"
#include "uvc_log.h"

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/prctl.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <drm/drm.h>

#include <list>
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
#include "drm.h"
#endif
#if UVC_DYNAMIC_DEBUG_FPS
struct uvc_debug_info_def uvc_debug_info;
#endif

struct uvc_buffer_list
{
    std::list<struct uvc_buffer *> buffer_list;
    pthread_mutex_t mutex;
};

struct video_uvc
{
    struct uvc_buffer_list write;
    struct uvc_buffer_list read;
    struct uvc_buffer_list all;
    pthread_t id;
    bool run;
    int video_id;
};

static std::list<struct uvc_video *> lst_v;
static pthread_mutex_t mtx_v = PTHREAD_MUTEX_INITIALIZER;


static struct uvc_buffer *uvc_buffer_create(int width, int height, struct uvc_video *v)
{
    struct uvc_buffer *buffer = NULL;

    buffer = (struct uvc_buffer *)calloc(1, sizeof(struct uvc_buffer));
    if (!buffer)
        return NULL;
    buffer->width = width;
    buffer->height = height;
    buffer->size = buffer->width * buffer->height * 2;
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
    unsigned int drm_flag = 0;
    buffer->drm_buf_size = buffer->size;
    if (v->drm_fd == -1)
        v->drm_fd = drm_open();
    if (v->drm_fd < 0)
        return NULL;
    if (v->uvc_user.fcc == V4L2_PIX_FMT_YUYV || v->uvc_user.fcc == V4L2_PIX_FMT_NV12)
        drm_flag = ROCKCHIP_BO_CACHABLE;

    int ret = drm_alloc(v->drm_fd, buffer->drm_buf_size, 16, &buffer->handle, drm_flag);
    if (ret)
    {
        LOG_ERROR("drm_alloc fail\n");
        return NULL;
    }

    ret = drm_handle_to_fd(v->drm_fd, buffer->handle, &buffer->fd, DRM_CLOEXEC | DRM_RDWR);
    if (ret)
    {
        LOG_ERROR("drm_handle_to_fd fail\n");
        return NULL;
    }
    buffer->buffer = (void *)drm_map_buffer(v->drm_fd, buffer->handle, buffer->drm_buf_size);
    LOG_DEBUG("v->drm_fd=%d,buffer->handle=%d,size=%d\n", v->drm_fd, buffer->handle, buffer->drm_buf_size);
#else
    buffer->buffer = calloc(1, buffer->size);
#endif
    if (!buffer->buffer)
    {
        free(buffer);
        return NULL;
    }
    buffer->total_size = buffer->size;
    buffer->video_id = v->id;
    return buffer;
}

static void uvc_buffer_push_back(struct uvc_buffer_list *uvc_buffer,
                                 struct uvc_buffer *buffer)
{
    pthread_mutex_lock(&uvc_buffer->mutex);
    uvc_buffer->buffer_list.push_back(buffer);
    pthread_mutex_unlock(&uvc_buffer->mutex);
}

static struct uvc_buffer *uvc_buffer_pop_front(
    struct uvc_buffer_list *uvc_buffer)
{
    struct uvc_buffer *buffer = NULL;

    pthread_mutex_lock(&uvc_buffer->mutex);
    if (!uvc_buffer->buffer_list.empty())
    {
        buffer = uvc_buffer->buffer_list.front();
        uvc_buffer->buffer_list.pop_front();
    }
    pthread_mutex_unlock(&uvc_buffer->mutex);
    return buffer;
}

static struct uvc_buffer *uvc_buffer_front(struct uvc_buffer_list *uvc_buffer)
{
    struct uvc_buffer *buffer = NULL;

    pthread_mutex_lock(&uvc_buffer->mutex);
    if (!uvc_buffer->buffer_list.empty())
        buffer = uvc_buffer->buffer_list.front();
    else //{printf("buff null\n");
        buffer = NULL;
//     }
    pthread_mutex_unlock(&uvc_buffer->mutex);
    return buffer;
}

#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
static void uvc_drm_buffer_destroy(struct uvc_video *v, struct uvc_buffer_list *uvc_buffer)
{
    struct uvc_buffer *buffer = NULL;

    pthread_mutex_lock(&uvc_buffer->mutex);
    while (!uvc_buffer->buffer_list.empty())
    {
        buffer = uvc_buffer->buffer_list.front();
        LOG_INFO("uvc_drm_buffer_destroy buffer->handle=%d size=%d\n", buffer->handle, buffer->drm_buf_size);
        drm_unmap_buffer(buffer->buffer, buffer->drm_buf_size);
        close(buffer->fd);
        drm_free(v->drm_fd, buffer->handle);
        free(buffer);
        uvc_buffer->buffer_list.pop_front();
    }
    pthread_mutex_unlock(&uvc_buffer->mutex);
    pthread_mutex_destroy(&uvc_buffer->mutex);

}
#endif
static void uvc_buffer_destroy(struct uvc_buffer_list *uvc_buffer)
{
    struct uvc_buffer *buffer = NULL;

    pthread_mutex_lock(&uvc_buffer->mutex);
    while (!uvc_buffer->buffer_list.empty())
    {
        buffer = uvc_buffer->buffer_list.front();
        free(buffer->buffer);
        free(buffer);
        uvc_buffer->buffer_list.pop_front();
    }
    pthread_mutex_unlock(&uvc_buffer->mutex);
    pthread_mutex_destroy(&uvc_buffer->mutex);
}

static void uvc_buffer_clear(struct uvc_buffer_list *uvc_buffer)
{
    pthread_mutex_lock(&uvc_buffer->mutex);
    uvc_buffer->buffer_list.clear();
    pthread_mutex_unlock(&uvc_buffer->mutex);
}

static void *uvc_gadget_pthread(void *arg)
{
    struct uvc_function_config *fc = (struct uvc_function_config *)arg;
    int *id = (int *)arg;

    prctl(PR_SET_NAME, "uvc_gadget_pthread", 0, 0, 0);

    uvc_gadget_main(fc);
    uvc_set_user_run_state(true, fc->video);

    pthread_exit(NULL);
}

int uvc_gadget_pthread_create(struct uvc_function_config *fc)
{
    pthread_t *pid = NULL;
    int id = fc->video;
    uvc_memset_uvc_user(id);
    if ((pid = uvc_video_get_uvc_pid(id)))
    {
        if (pthread_create(pid, NULL, uvc_gadget_pthread, fc))
        {
            LOG_ERROR("create uvc_gadget_pthread fail!\n");
            return -1;
        }
    }
    return 0;
}

static int _uvc_video_id_check(int id)
{
    int ret = 0;

    if (!lst_v.empty())
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                ret = -1;
                break;
            }
        }
    }

    return ret;
}

int uvc_video_id_check(int id)
{
    int ret = 0;

    pthread_mutex_lock(&mtx_v);
    ret = _uvc_video_id_check(id);
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

int uvc_video_id_add(struct uvc_function_config *fc)
{
    int ret = 0;
    int id = fc->video;

    LOG_INFO("add uvc video id: %d\n", id);

    pthread_mutex_lock(&mtx_v);
    if (!_uvc_video_id_check(id))
    {
        struct uvc_video *v = (struct uvc_video *)calloc(1, sizeof(struct uvc_video));
        if (v)
        {
            v->id = id;
            lst_v.push_back(v);
            pthread_mutex_unlock(&mtx_v);
            uvc_gadget_pthread_create(fc);
            pthread_mutex_lock(&mtx_v);
            pthread_mutex_init(&v->buffer_mutex, NULL);
            pthread_mutex_init(&v->user_mutex, NULL);
            ret = 0;
        }
        else
        {
            LOG_ERROR("%s: %d: memory alloc fail.\n", __func__, __LINE__);
            ret = -1;
        }
    }
    else
    {
        LOG_WARN("%s: %d: %d already exist.\n", __func__, __LINE__, id);
        ret = -1;
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

void uvc_video_id_remove(int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                pthread_mutex_destroy(&l->buffer_mutex);
                pthread_mutex_destroy(&l->user_mutex);
                free(l);
                lst_v.erase(i);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

int uvc_video_id_get(unsigned int seq)
{
    int ret = -1;

    pthread_mutex_lock(&mtx_v);
    if (!lst_v.empty())
    {
        unsigned int cnt = 0;
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            if (cnt++ == seq)
            {
                struct uvc_video *l = *i;
                ret = l->id;
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

static void uvc_gadget_pthread_exit(int id);

static int uvc_video_id_exit(int id)
{
    if (uvc_video_id_check(id))
    {
        uvc_gadget_pthread_exit(id);
        uvc_video_id_remove(id);
        return 0;
    }

    return -1;
}

static int _uvc_video_id_exit_all()
{
    int ret = -1;

    pthread_mutex_lock(&mtx_v);
    if (!lst_v.empty())
    {
        struct uvc_video *l = lst_v.front();
        pthread_mutex_unlock(&mtx_v);
        uvc_video_id_exit(l->id);
        pthread_mutex_lock(&mtx_v);
        ret = 0;
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

void uvc_video_id_exit_all()
{
    while (!_uvc_video_id_exit_all())
        continue;
}

static void _uvc_video_set_uvc_process(struct uvc_video *v, bool state)
{
    v->uvc_process = state;
}

void uvc_video_set_uvc_process(int id, bool state)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_video_set_uvc_process(l, state);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static bool _uvc_video_get_uvc_process(struct uvc_video *v)
{
    return v->uvc_process;
}

bool uvc_video_get_uvc_process(int id)
{
    bool state = false;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                state = _uvc_video_get_uvc_process(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return state;
}

pthread_t *uvc_video_get_uvc_pid(int id)
{
    pthread_t *tid = NULL;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                tid = &l->uvc_pid;
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return tid;
}

void uvc_video_join_uvc_pid(int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                if (l->uvc_pid)
                {
                    pthread_mutex_unlock(&mtx_v);
                    pthread_join(l->uvc_pid, NULL);
                    l->uvc_pid = 0;
                    pthread_mutex_lock(&mtx_v);
                }
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static void uvc_gadget_pthread_exit(int id)
{
    while (!uvc_get_user_run_state(id))
        pthread_yield();
    uvc_set_user_run_state(false, id);
    uvc_video_join_uvc_pid(id);
}

static void _uvc_get_user_resolution(struct uvc_video *v, int *width, int *height);

static int _uvc_buffer_init(struct uvc_video *v)
{
    int i = 0;
    int ret = 0;
    struct uvc_buffer *buffer = NULL;
    int width, height;

    _uvc_get_user_resolution(v, &width, &height);

    pthread_mutex_lock(&v->buffer_mutex);

    v->uvc = new video_uvc();
    if (!v->uvc)
    {
        ret = -1;
        goto exit;
    }
    v->uvc->id = 0;
    v->uvc->video_id = v->id;
    v->uvc->run = 1;
    v->buffer_s = NULL;
    pthread_mutex_init(&v->uvc->write.mutex, NULL);
    pthread_mutex_init(&v->uvc->read.mutex, NULL);

    uvc_buffer_clear(&v->uvc->write);
    uvc_buffer_clear(&v->uvc->read);
    uvc_buffer_clear(&v->uvc->all);

    LOG_DEBUG("UVC_BUFFER_NUM = %d\n", UVC_BUFFER_NUM);
    v->drm_fd = -1;
    for (i = 0; i < UVC_BUFFER_NUM; i++)
    {
        buffer = uvc_buffer_create(width, height, v);
        if (!buffer)
        {
            ret = -1;
            goto exit;
        }
#if (UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF)
        uvc_buffer_push_back(&v->uvc->all, buffer);
#endif
        uvc_buffer_push_back(&v->uvc->write, buffer);

    }
    _uvc_video_set_uvc_process(v, true);
    v->can_exit = true;

exit:
    pthread_mutex_unlock(&v->buffer_mutex);
    return ret;
}

int uvc_buffer_init(int id)
{
    int ret = -1;
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                ret = _uvc_buffer_init(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

static void _uvc_buffer_deinit(struct uvc_video *v)
{
    pthread_mutex_lock(&v->buffer_mutex);
    if (v->uvc)
    {
        v->uvc->run = 0;
        _uvc_video_set_uvc_process(v, false);
        if (v->buffer_s)
            uvc_buffer_push_back(&v->uvc->write, v->buffer_s);
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER

#if UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF
        LOG_DEBUG("_uvc_buffer_deinit all\n");
        uvc_drm_buffer_destroy(v, &v->uvc->all);
#else
        LOG_DEBUG("_uvc_buffer_deinit write\n");
        uvc_drm_buffer_destroy(v, &v->uvc->write);
        LOG_DEBUG("_uvc_buffer_deinit read\n");
        uvc_drm_buffer_destroy(v, &v->uvc->read);
#endif
        drm_close(v->drm_fd);
        LOG_DEBUG("_uvc_buffer_deinit drm_close drm_fd:%d\n", v->drm_fd);
        v->drm_fd = -1;
#else
        uvc_buffer_destroy(&v->uvc->write);
        uvc_buffer_destroy(&v->uvc->read);
#endif
        delete v->uvc;
        v->uvc = NULL;
    }
    pthread_mutex_unlock(&v->buffer_mutex);
}

void uvc_buffer_deinit(int id)
{
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
    struct uvc_video *l;
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            l = *i;
            if (id == l->id)
            {
                break;
            }
        }
    }
    int wait_cnt = 0;
    while (l->uvc_process && !l->can_exit)
    {
        wait_cnt++;
        usleep(1000);
        if (wait_cnt > 30) {
          LOG_INFO("uvc_buffer_deinit timeout 30ms,force exit!\n");
          break;
        }
    }

    pthread_mutex_lock(&mtx_v);
    _uvc_buffer_deinit(l);
    pthread_mutex_unlock(&mtx_v);
#else
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_buffer_deinit(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
#endif
}

static bool _uvc_buffer_write_enable(struct uvc_video *v)
{
    bool ret = false;

    if (pthread_mutex_trylock(&v->buffer_mutex))
        return ret;
    if (v->uvc && uvc_buffer_front(&v->uvc->write))
        ret = true;
    pthread_mutex_unlock(&v->buffer_mutex);
    return ret;
}

bool uvc_buffer_write_enable(int id)
{
    bool ret = false;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                ret = _uvc_buffer_write_enable(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

static bool _uvc_buffer_read_enable(struct uvc_video *v)
{
    bool ret = false;

    if (pthread_mutex_trylock(&v->buffer_mutex))
        return ret;
    if (v->uvc && uvc_buffer_front(&v->uvc->read))
        ret = true;
    pthread_mutex_unlock(&v->buffer_mutex);
    return ret;
}

bool uvc_buffer_read_enable(int id)
{
    bool ret = false;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                ret = _uvc_buffer_read_enable(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

static bool _uvc_mpp_buffer_write_enable(struct uvc_video *v)
{
    bool ret = false;

    //if (pthread_mutex_trylock(&v->buffer_mutex))
    //    return ret;
    if (v->uvc && uvc_buffer_front(&v->uvc->write))
        ret = true;
    // pthread_mutex_unlock(&v->buffer_mutex);
    return ret;
}

bool uvc_mpp_buffer_write_enable(int id)
{
    bool ret = false;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                ret = _uvc_buffer_write_enable(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return ret;
}

#define EX_MAX_LEN 65535
#define EX_DATA_LEN (EX_MAX_LEN - 2)
static void _uvc_buffer_write(struct uvc_video *v,
                              unsigned short stamp,
                              void *extra_data,
                              size_t extra_size,
                              void *data,
                              size_t size,
                              unsigned int fcc)
{
    const size_t cnt = extra_size / (EX_DATA_LEN + 1) + 1;
    pthread_mutex_lock(&v->buffer_mutex);
    if (v->uvc && data)
    {
        struct uvc_buffer *buffer = uvc_buffer_pop_front(&v->uvc->write);
        if (buffer && buffer->buffer)
        {
            if (buffer->total_size >= extra_size + size)
            {
                switch (fcc)
                {
                case V4L2_PIX_FMT_YUYV:
#if YUYV_AS_RAW
#ifdef USE_RK_MODULE
                    raw16_to_raw8(buffer->width, buffer->height, data, buffer->buffer);
#else
                    memcpy(buffer->buffer, data, size);
#endif
#else
                    NV12_to_YUYV(buffer->width, buffer->height, data, buffer->buffer);
#endif
                    break;
                case V4L2_PIX_FMT_MJPEG:
                    if (extra_data && buffer->total_size >= extra_size + size + 4 * cnt)
                    {
                        size_t index = 4;// FF D8 FF E0
                        size_t len = *((unsigned char *)data + index);
                        len = len * 256 + *((unsigned char *)data + index + 1);
                        index = index + len;
                        memcpy(buffer->buffer, data, index);
                        size_t ind = index;
                        for (size_t i = 1; i < cnt; i++)
                        {
                            memset((char *)buffer->buffer + ind, 0xFF, 1);
                            ind++;
                            memset((char *)buffer->buffer + ind, 0xE2, 1);
                            ind++;
                            memset((char *)buffer->buffer + ind, EX_MAX_LEN / 256, 1);
                            ind++;
                            memset((char *)buffer->buffer + ind, EX_MAX_LEN % 256, 1);
                            ind++;
                            memcpy((char *)buffer->buffer + ind,
                                   (char *)extra_data + (i - 1) * EX_DATA_LEN, EX_DATA_LEN);
                            ind += EX_DATA_LEN;
                        }
                        memset((char *)buffer->buffer + ind, 0xFF, 1);
                        ind ++;
                        memset((char *)buffer->buffer + ind, 0xE2, 1);
                        ind++;
                        memset((char *)buffer->buffer + ind,
                               (2 + extra_size - EX_DATA_LEN * (cnt - 1)) / 256, 1);
                        ind++;
                        memset((char *)buffer->buffer + ind,
                               (2 + extra_size - EX_DATA_LEN * (cnt - 1)) % 256, 1);
                        ind++;
                        memcpy((char *)buffer->buffer + ind,
                               (char *)extra_data + EX_DATA_LEN * (cnt - 1),
                               extra_size - EX_DATA_LEN * (cnt - 1));
                        ind += extra_size - EX_DATA_LEN * (cnt - 1);
                        memcpy((char *)buffer->buffer + ind,
                               (char *)data + index, size - index);
                        extra_size += 4 * cnt;
                    }
                    else
                    {
                        memcpy(buffer->buffer, data, size);
                    }
                    //memcpy((char*)buffer->buffer + size, &stamp, sizeof(stamp));
                    //size += sizeof(stamp);
                    break;
                case V4L2_PIX_FMT_H264:
                case V4L2_PIX_FMT_H265:
                    if (extra_data && extra_size > 0)
                        memcpy(buffer->buffer, extra_data, extra_size);
                    if (extra_size >= 0)
                        memcpy((char *)buffer->buffer + extra_size, data, size);
                    break;
                }
                buffer->size = extra_size + size;
                uvc_buffer_push_back(&v->uvc->read, buffer);
            }
            else
            {
                uvc_buffer_push_back(&v->uvc->write, buffer);
            }
        }
    }
    pthread_mutex_unlock(&v->buffer_mutex);
}

void uvc_buffer_write(unsigned short stamp,
                      void *extra_data,
                      size_t extra_size,
                      void *data,
                      size_t size,
                      unsigned int fcc,
                      int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_buffer_write(l, stamp, extra_data, extra_size, data, size, fcc);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
struct uvc_buffer *uvc_buffer_write_get(int id)
{
    struct uvc_buffer *buffer = NULL;
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                l->can_exit = false;
                pthread_mutex_lock(&l->buffer_mutex);
                buffer = uvc_buffer_pop_front(&l->uvc->write);
                pthread_mutex_unlock(&l->buffer_mutex);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
    return buffer;
}

struct uvc_buffer *uvc_buffer_write_get_nolock(int id)
{
    struct uvc_buffer *buffer = NULL;
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                l->can_exit = false;
                pthread_mutex_lock(&l->buffer_mutex);
                buffer = uvc_buffer_pop_front(&l->uvc->write);
                //if (l->)
                pthread_mutex_unlock(&l->buffer_mutex);
                break;
            }
        }
    }
    return buffer;
}

void uvc_buffer_read_set_nolock(int id, struct uvc_buffer *buf)
{
#if 1
    //uvc_ipc_test_write();

#endif
    if (buf->abandon)
    {
        LOG_INFO("uvc_buffer_read_set_nolock abandon\n");
    }
    else if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                l->can_exit = true;
                pthread_mutex_lock(&l->buffer_mutex);
                uvc_buffer_push_back(&l->uvc->read, buf);
                pthread_mutex_unlock(&l->buffer_mutex);
//                l->shm_control->sendUVCBuffer();
                break;
            }
        }
    }
}

void uvc_buffer_read_set(int id, struct uvc_buffer *buf)
{
    pthread_mutex_lock(&mtx_v);
    if (buf->abandon)
    {
        LOG_INFO("uvc_buffer_read_set abandon\n");
    }
    else if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                l->can_exit = true;
                pthread_mutex_lock(&l->buffer_mutex);
                uvc_buffer_push_back(&l->uvc->read, buf);
                pthread_mutex_unlock(&l->buffer_mutex);
                break;
            }
        }
    }

    pthread_mutex_unlock(&mtx_v);
}

void uvc_buffer_write_set(int id, struct uvc_buffer *buf)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                // l->can_exit = true;
                pthread_mutex_lock(&l->buffer_mutex);
                uvc_buffer_push_back(&l->uvc->write, buf);
                pthread_mutex_unlock(&l->buffer_mutex);
                break;
            }
        }
    }

    pthread_mutex_unlock(&mtx_v);
}

void uvc_buffer_all_set(int id, struct uvc_buffer *buf)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                // l->can_exit = true;
                pthread_mutex_lock(&l->buffer_mutex);
                uvc_buffer_push_back(&l->uvc->all, buf);
                pthread_mutex_unlock(&l->buffer_mutex);
                break;
            }
        }
    }

    pthread_mutex_unlock(&mtx_v);
}

#endif
static void _uvc_set_user_resolution(struct uvc_video *v, int width, int height)
{
    pthread_mutex_lock(&v->user_mutex);
    v->uvc_user.width = width;
    v->uvc_user.height = height;
    LOG_DEBUG("uvc_user.width = %u, uvc_user.height = %u\n", v->uvc_user.width,
             v->uvc_user.height);
    pthread_mutex_unlock(&v->user_mutex);
}

void uvc_set_user_resolution(int width, int height, int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_set_user_resolution(l, width, height);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static void _uvc_get_user_resolution(struct uvc_video *v, int *width, int *height)
{
    pthread_mutex_lock(&v->user_mutex);
    *width = v->uvc_user.width;
    *height = v->uvc_user.height;
    pthread_mutex_unlock(&v->user_mutex);
}

void uvc_get_user_resolution(int *width, int *height, int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_get_user_resolution(l , width, height);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static bool _uvc_get_user_run_state(struct uvc_video *v)
{
    bool ret;

    pthread_mutex_lock(&v->user_mutex);
    ret = v->uvc_user.run;
    pthread_mutex_unlock(&v->user_mutex);

    return ret;
}

bool uvc_get_user_run_state(int id)
{
    bool state = false;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                state = _uvc_get_user_run_state(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return state;
}

#if UVC_SEND_BUF_WHEN_ENC_READY
#ifdef RK_MPP_USE_UVC_VIDEO_BUFFER
int uvc_video_qbuf_index(struct uvc_device *dev, struct uvc_buffer *send_buf, int index, int len)
{
#if 0
    LOG_INFO("uvc_video_qbuf_index enter send_buf=%p,index:%d len=%d,dev->nbufs=%d\n",
                     send_buf, index, len, dev->nbufs);
#endif
    unsigned int i;
    int ret;
    struct v4l2_requestbuffers req;
    memset(&req, 0, sizeof (req));

    req.count = dev->nbufs;
    req.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
    req.memory = V4L2_MEMORY_DMABUF;
    if (index == 0) {
        uvc_video_reqbufs(dev, dev->nbufs);
        uvc_video_stream(dev, 1);
        dev->vbuf_info = (struct v4l2_buffer_info *)calloc(dev->nbufs, sizeof(struct v4l2_buffer_info));
    }

    /* UVC standalone setup. */
    if (dev->run_standalone)
    {
        struct v4l2_buffer buf;
        memset(&buf, 0, sizeof(buf));
        buf.type = req.type;
        buf.index = index;
        buf.memory = req.memory;

        struct uvc_buffer *uvc_buf = send_buf;//uvc_buffer_write_get(dev->video_id);
        buf.m.fd = uvc_buf->fd;
        buf.length = uvc_buf->total_size;
        buf.bytesused = len;
        dev->ubuf.bytesused = len;
        dev->vbuf_info[index].fd = buf.m.fd;
        dev->vbuf_info[index].uvc_buf = uvc_buf;
        dev->vbuf_info[index].index = index;

        if (ioctl(dev->uvc_fd, VIDIOC_QBUF, &buf) < 0)
        {
            LOG_ERROR("%s ioctl(VIDIOC_QBUF): %m,buf.m.fd=%d,buf.length=%d\n", dev, buf.m.fd,  buf.length);
            return -1;
        }
        else
        {
            LOG_INFO("V4L2: %u buffers allocated index:%d\n", dev->nbufs, index);
        }
    }

    return 0;
}
#endif
#endif
static void _uvc_set_user_run_state(struct uvc_video *v, bool state)
{
    pthread_mutex_lock(&v->user_mutex);
    v->uvc_user.run = state;
    pthread_mutex_unlock(&v->user_mutex);
}

void uvc_set_user_run_state(bool state, int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_set_user_run_state(l, state);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static void _uvc_set_user_fcc(struct uvc_video *v, unsigned int fcc)
{
    v->uvc_user.fcc = fcc;
}

void uvc_set_user_fcc(unsigned int fcc, int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_set_user_fcc(l, fcc);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static unsigned int _uvc_get_user_fcc(struct uvc_video *v)
{
    return v->uvc_user.fcc;
}

unsigned int uvc_get_user_fcc(int id)
{
    unsigned int fcc = 0;

    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                fcc = _uvc_get_user_fcc(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);

    return fcc;
}

static void _uvc_memset_uvc_user(struct uvc_video *v)
{
    memset(&v->uvc_user, 0, sizeof(struct uvc_user));
}

void uvc_memset_uvc_user(int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_memset_uvc_user(l);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static bool _uvc_buffer_check(struct uvc_video *v, struct uvc_buffer *buffer)
{
    int width = 0, height = 0;

    _uvc_get_user_resolution(v, &width, &height);
    if (buffer->width == width && buffer->height == height)
        return true;
    else
        return false;
}

static void uvc_delay_time_calcu_before_get(struct uvc_device *dev, struct uvc_video *v)
{
#if UVC_DYNAMIC_DEBUG_USE_TIME
    if (!access(UVC_DYNAMIC_DEBUG_USE_TIME_CHECK, 0))
    {
        int32_t use_time_us, now_time_us;
        struct timespec now_tm = {0, 0};
        clock_gettime(CLOCK_MONOTONIC, &now_tm);
        now_time_us = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000; // us
        use_time_us = now_time_us - v->last_pts;   //usb send ok and calcu the latency time use last pts
        LOG_INFO("isp->mpp->usb_ready->usb_send_ok seq:%d latency time:%d us, %d ms\n", v->last_seq, use_time_us, use_time_us / 1000);
    }

    if (dev->usb_state == USB_STATE_FIRST_GET_READY)
    {
        int32_t use_time_us;
        struct timespec now_tm = {0, 0};
        clock_gettime(CLOCK_MONOTONIC, &now_tm);
        dev->usb_state = USB_STATE_FIRST_GET_OK;
        dev->first_usb_get_ready_pts = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000;
        use_time_us = dev->first_usb_get_ready_pts - dev->stream_on_pts;
        LOG_INFO("steamon->get_ready latency time:%d us, %d ms\n", use_time_us, use_time_us / 1000);
    }
    else if (dev->usb_state == USB_STATE_FIRST_SEND_OK)
    {
        struct timespec now_tm = {0, 0};
        int32_t use_time_us;
        clock_gettime(CLOCK_MONOTONIC, &now_tm);
        dev->first_usb_send_ok_pts = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000;
        dev->usb_state = USB_STATE_NORMAL_RUN;
        use_time_us = dev->first_usb_send_ok_pts - dev->stream_on_pts;
        LOG_INFO("steamon->get_ready->get_ok->send_ok latency time:%d us, %d ms\n", use_time_us, use_time_us / 1000);
        use_time_us = dev->first_usb_send_ok_pts - v->last_pts;
        LOG_INFO("isp->mpp->usb_ready->usb_send_ok seq:%d latency time:%d us, %d ms\n", v->last_seq, use_time_us, use_time_us / 1000);
    }
#endif

}

static void uvc_delay_time_calcu_after_get(struct uvc_device *dev, struct uvc_video *v, struct uvc_buffer *buffer)
{
#if UVC_DYNAMIC_DEBUG_USE_TIME
    if (dev->usb_state == USB_STATE_FIRST_GET_OK)
    {
        struct timespec now_tm = {0, 0};
        int32_t use_time_us;
        clock_gettime(CLOCK_MONOTONIC, &now_tm);
        dev->first_usb_get_ok_pts = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000;
        dev->usb_state = USB_STATE_FIRST_SEND_OK;
        use_time_us = dev->first_usb_get_ok_pts - dev->stream_on_pts;
        LOG_INFO("steamon->get_ready->get_ok seq:%d time:%d us, %d ms\n", buffer->seq, use_time_us, use_time_us / 1000);
    }

    v->last_pts = buffer->pts;
    v->now_pts = buffer->pts;
    v->last_seq = buffer->seq;
    if (!access(UVC_DYNAMIC_DEBUG_USE_TIME_CHECK, 0))
    {
        int32_t use_time_us, now_time_us;
        struct timespec now_tm = {0, 0};
        clock_gettime(CLOCK_MONOTONIC, &now_tm);
        now_time_us = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000; // us
        use_time_us = now_time_us - v->now_pts;
        LOG_INFO("isp->mpp->usb_ready seq:%d latency time:%d us, %d ms\n", buffer->seq, use_time_us, use_time_us / 1000);
    }
#endif
}
static int drop_frame_cnt = 0;
struct uvc_buffer *uvc_get_enc_data(struct uvc_device *dev, struct uvc_video *v, bool init)
{
    struct uvc_buffer *buffer = NULL;
    v->idle_cnt = 0;
    int time_out = 60;
    if (init)
        time_out = 30;
    while (!(buffer = uvc_buffer_front(&v->uvc->read)) && _uvc_get_user_run_state(v))
    {
        pthread_mutex_unlock(&mtx_v);
        usleep(1000);
        v->idle_cnt++;
        pthread_mutex_lock(&mtx_v);
        if (v->idle_cnt > time_out)
        {
            if(!(buffer = uvc_buffer_front(&v->uvc->read)) && _uvc_get_user_run_state(v)) // onece more check it.
            {
                if (init == false) {
                    if(drop_frame_cnt == 0) {
                      LOG_DEBUG("fill buf timeout %d ms, abandon this write buf %d\n",time_out, v->buffer_s->fd);
                    }
                    //v->buffer_s->abandon = true;
                    //uvc_buffer_pop_front(&v->uvc->write);
                } else {
                    if(drop_frame_cnt == 0) {
                       LOG_DEBUG("init:%d,fill buf timeout %d ms\n", init, time_out);
                    }
                }
                drop_frame_cnt++;
                if(drop_frame_cnt > 200) {
                   if (access("/tmp/uvc_camera_no_buf", 0)) {
                     LOG_INFO("it's already 200 frames buf no to get from CAMERA,tell watchdog now\n");
                     system("touch /tmp/uvc_camera_no_buf &");
                   }
                   drop_frame_cnt = 0;
                }
            }
            break;
        }
    }
   // LOG_INFO("init:%d,uvc_get_enc_data: %p\n", init, buffer);
#if UVC_SEND_BUF_WHEN_ENC_READY
    if (init && buffer) {
        uvc_video_qbuf_index(dev, buffer, dev->get_buf_count, buffer->size);
    }
#endif

    if (buffer)
        uvc_delay_time_calcu_after_get(dev, v, buffer);
    return buffer;
}

#if UVC_SEND_BUF_WHEN_ENC_READY
struct uvc_buffer *uvc_user_fill_buffer_init(struct uvc_device *dev)
{
    pthread_mutex_lock(&mtx_v);
    struct uvc_buffer *buffer = NULL;
    if (_uvc_video_id_check(dev->video_id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (dev->video_id == l->id)
            {
                uvc_delay_time_calcu_before_get(dev, l);
                if(uvc_get_enc_data(dev, l, true)) {
                    buffer = uvc_buffer_pop_front(&l->uvc->read);
                }
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
    return buffer;
}
#endif

static void _uvc_user_fill_buffer(struct uvc_video *v, struct uvc_device *dev, struct v4l2_buffer *buf)
{
    struct uvc_buffer *buffer = NULL;
    bool get_ok = false;
    uvc_delay_time_calcu_before_get(dev, v);

#if 0//UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF
    for (int i = 0; i < dev->nbufs; i++)
    {
        if (dev->vbuf_info[i].fd == buf->m.fd)
        {
            v->buffer_s = dev->vbuf_info[i].uvc_buf;
            v->buffer_s->abandon = false;
            break;
        }
    }
    uvc_buffer_push_back(&v->uvc->write, v->buffer_s);
#endif

    buffer = uvc_get_enc_data(dev, v, false);
    if (buffer)
    {
        for (int i = 0; i < dev->nbufs; i++)
        {
            if (buffer == dev->vbuf_info[i].uvc_buf)
            {
                buf->index = dev->vbuf_info[i].index;
                buf->sequence = buffer->seq;
                buf->m.fd = dev->vbuf_info[i].fd;
                get_ok = true;
                break;
            }
        }

        if (get_ok == false || !_uvc_buffer_check(v, buffer)) {
            LOG_ERROR("fail:%d\n", get_ok);
            return;
        }
        if (_uvc_get_user_run_state(v) && _uvc_video_get_uvc_process(v))
        {
            if (buf->length >= buffer->size && buffer->buffer)
            {
                // buf->bytesused = 550*1024;//for test
                buf->bytesused = buffer->size;
#if UVC_IO_METHOD == UVC_IO_METHOD_MMAP
                memcpy(dev->mem[buf->index].start, buffer->buffer, buffer->size);
#elif UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF

#else
                dev->mem[buf->index].start = buffer->buffer;
#endif
                drop_frame_cnt = 0;
            }
        }
        else
        {
            LOG_WARN("_uvc_user_fill_buffer no go here \n");
#if UVC_IO_METHOD == UVC_IO_METHOD_MMAP
            buf->bytesused = buf->length;
#elif UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF
            buf->bytesused = 0;
#else
            buf->bytesused = buf->length;
#endif
        }

        buffer = uvc_buffer_pop_front(&v->uvc->read);
#if UVC_IO_METHOD == UVC_IO_METHOD_MMAP
        if (!v->buffer_s)
        {
            v->buffer_s = buffer;
        }
        else
        {
            uvc_buffer_push_back(&v->uvc->write, v->buffer_s);
            v->buffer_s = buffer;
        }
#elif UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF

#else

#endif

    }
    else if (v->buffer_s)
    {
        if (!_uvc_buffer_check(v, v->buffer_s))
            return;
        if (_uvc_get_user_run_state(v) && _uvc_video_get_uvc_process(v))
        {
            if (buf->length >= v->buffer_s->size && v->buffer_s->buffer)
            {
                buf->bytesused = v->buffer_s->size;
#if UVC_IO_METHOD == UVC_IO_METHOD_MMAP
                memcpy(dev->mem[buf->index].start, v->buffer_s->buffer, v->buffer_s->size);
#elif UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF
                buf->bytesused = 0;
                buf->m.fd = 0;
#else
                dev->mem[buf->index].start = v->buffer_s->buffer;
#endif
            }
        }
    }
    else
    {
        buf->bytesused = 0;
        buf->m.fd = 0;
#if UVC_IO_METHOD == UVC_IO_METHOD_MMAP
        memset(dev->mem[buf->index].start, 0, buf->length);
#elif UVC_IO_METHOD == UVC_IO_METHOD_DMA_BUFF

#else

#endif
    }

}

void uvc_user_fill_buffer(struct uvc_device *dev, struct v4l2_buffer *buf, int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_user_fill_buffer(l, dev, buf);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

static void _uvc_user_set_write_buffer(struct uvc_video *v, struct uvc_device *dev, struct v4l2_buffer *buf)
{
    struct uvc_buffer *buffer = NULL;
    bool get_ok = false;
 //   uvc_delay_time_calcu_before_get(dev, v);
    for (int i = 0; i < dev->nbufs; i++)
    {
        if (dev->vbuf_info[i].fd == buf->m.fd)
        {
            v->buffer_s = dev->vbuf_info[i].uvc_buf;
            v->buffer_s->abandon = false;
            get_ok = true;
            break;
        }
    }
    if (get_ok)
        uvc_buffer_push_back(&v->uvc->write, v->buffer_s);
    else
        LOG_ERROR("fail:%d\n", buf->m.fd);
}

void uvc_user_set_write_buffer(struct uvc_device *dev, struct v4l2_buffer *buf, int id)
{
    pthread_mutex_lock(&mtx_v);
    if (_uvc_video_id_check(id))
    {
        for (std::list<struct uvc_video *>::iterator i = lst_v.begin(); i != lst_v.end(); ++i)
        {
            struct uvc_video *l = *i;
            if (id == l->id)
            {
                _uvc_user_set_write_buffer(l, dev, buf);
                break;
            }
        }
    }
    pthread_mutex_unlock(&mtx_v);
}

void uvc_user_lock()
{
    pthread_mutex_lock(&mtx_v);
}

void uvc_user_unlock()
{
    pthread_mutex_unlock(&mtx_v);
}