// Copyright 2019 Fuzhou Rockchip Electronics Co., Ltd. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <sys/prctl.h>
#include <sys/time.h>


#include "uvc_ipc.h"
#include "uvc_log.h"
#include "drm.h"
#include "mpi_enc.h"

#ifdef LOG_TAG
#undef LOG_TAG
#endif
#define LOG_TAG "uvc_ipc"

namespace ShmControl
{
struct UVC_IPC_INFO uvc_ipc_info;

// TODO: (lxh) add handle here for use instead global handle
extern "C" struct UVC_IPC_INFO *uvc_ipc_get_uvc_info_hd()
{
    return &uvc_ipc_info;
}

extern "C" void uvc_ipc_init()
{
    if (uvc_ipc_info.shm_control == NULL)
    {
        uvc_ipc_info.shm_control = new ShmUVCController();
//       uvc_ipc_info.shm_control->startRecvMessage();
        uvc_ipc_info.start = true;
        LOG_INFO("uvc_ipc_init first ok\n");
    }
    else
        LOG_INFO("uvc_ipc_init yet\n");
}

extern "C" void uvc_ipc_reinit()
{

    if (uvc_ipc_info.shm_control)
        delete uvc_ipc_info.shm_control;
    LOG_INFO("uvc_ipc_reinit ok\n");
}

extern "C" void uvc_ipc_event(enum UVC_IPC_EVENT event, void *data)
{
//    LOG_INFO("enter uvc_ipc_event event:%s\n", shm_meg_name[event - 1].c_str());
    pthread_mutex_lock(&uvc_ipc_info.mutex);
    if (uvc_ipc_info.start == false) //now only start onece
    {
        uvc_ipc_init();
    }
    switch (event)
    {
    case UVC_IPC_EVENT_START:
        if (uvc_ipc_info.stop)
        {
          uvc_ipc_info.stop = false;
          uvc_ipc_info.shm_control->clearRecvMessage(); // clear the last data
          uvc_ipc_info.shm_control->startRecvMessage();
          uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_START, data);
          if (uvc_ipc_info.history[0] == true)
          {
            LOG_INFO("history eptz:%d\n", uvc_ipc_info.enable_eptz);
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_ENABLE_ETPTZ, (void *)&uvc_ipc_info.enable_eptz);
            uvc_ipc_info.history[0] = false;
            uvc_ipc_info.history[2] = false;
            uvc_ipc_info.history[3] = false;
          } else {
            if (uvc_ipc_info.history[2] == true)
            {
                LOG_INFO("history eptz_pan:%d\n", uvc_ipc_info.zoom);
                uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_SET_ZOOM, (void *)&uvc_ipc_info.zoom);
                uvc_ipc_info.history[2] = false;
            }
            if (uvc_ipc_info.history[3] == true)
            {
                LOG_INFO("history eptz_tilt:%d\n", uvc_ipc_info.zoom);
                uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_SET_ZOOM, (void *)&uvc_ipc_info.zoom);
                uvc_ipc_info.history[3] = false;
            }
          }
          if (uvc_ipc_info.history[1] == true)
          {
            LOG_INFO("history zoom:%d\n", uvc_ipc_info.zoom);
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_SET_ZOOM, (void *)&uvc_ipc_info.zoom);
            uvc_ipc_info.history[1] = false;
          }
        }
        break;
    case UVC_IPC_EVENT_STOP:
        if (!uvc_ipc_info.stop)
        {
            uvc_ipc_info.shm_control->stopRecvMessage(); //clear the recv data
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_STOP, data);
            uvc_ipc_info.shm_control->ShmUVCDrmRelease();
            uvc_ipc_info.stop = true;
        }
        else
        {
            LOG_INFO("UVC_IPC_EVENT_STOP yet!\n");
        }
//        uvc_ipc_reinit();
        break;
    case UVC_IPC_EVENT_ENABLE_ETPTZ:
#if UVC_STREAM_OFF_NOT_SEND_SETTING
        if (uvc_ipc_info.stop)
        {
            int *val = (int *)data;
            uvc_ipc_info.enable_eptz = *val;
            uvc_ipc_info.history[0] = true;
            LOG_INFO("eptz can't set %d now, UVC_IPC_EVENT_STOP yet! wait for next start effect!\n",
                      uvc_ipc_info.enable_eptz);
        }
        else
#endif
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_ENABLE_ETPTZ, data);
        break;
    case UVC_IPC_EVENT_SET_ZOOM:
#if UVC_STREAM_OFF_NOT_SEND_SETTING
        if (uvc_ipc_info.stop)
        {
            int *val = (int *)data;
            uvc_ipc_info.zoom = *val;
            uvc_ipc_info.history[1] = true;
            LOG_INFO("zoom can't set %d now, UVC_IPC_EVENT_STOP yet! wait for next start effect!\n",
                      uvc_ipc_info.zoom);
        }
        else
#endif
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_SET_ZOOM, data);
        break;
    case UVC_IPC_EVENT_RET_TRANSPORT_BUF:
        uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_TRANSPORT_BUF, data);
        break;
    case UVC_IPC_EVENT_CONFIG_CAMERA:
        if (uvc_ipc_info.stop)
        {
            if (uvc_ipc_info.shm_control != NULL) {
                uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_CONFIG_CAMERA, data);
            }
        }
        break;
    case MSG_UVC_SET_EPTZ_PAN:
#if UVC_STREAM_OFF_NOT_SEND_SETTING
        if (uvc_ipc_info.stop)
        {
            int *val = (int *)data;
            uvc_ipc_info.eptz_pan = *val;
            uvc_ipc_info.history[0] = false;
            uvc_ipc_info.history[2] = true;
            LOG_INFO("eptz_pan can't set %d now, UVC_IPC_EVENT_STOP yet! wait for next start effect!\n",
                      uvc_ipc_info.eptz_pan);
        }
        else
#endif
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_SET_EPTZ_PAN, data);
        break;
    case MSG_UVC_SET_EPTZ_TILT:
#if UVC_STREAM_OFF_NOT_SEND_SETTING
        if (uvc_ipc_info.stop)
        {
            int *val = (int *)data;
            uvc_ipc_info.eptz_tilt = *val;
            uvc_ipc_info.history[0] = false;
            uvc_ipc_info.history[3] = true;
            LOG_INFO("eptz_tilt can't set %d now, UVC_IPC_EVENT_STOP yet! wait for next start effect!\n",
                      uvc_ipc_info.eptz_tilt);
        }
        else
#endif
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_SET_EPTZ_TILT, data);
        break;
     case UVC_IPC_EVENT_ENABLE_BYPASS:
            LOG_INFO("switch get stream from bypass link\n");
            uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_ENABLE_BYPASS, data);
        break;
    default:
        LOG_INFO("no support such uvc_ipc_event event:%d\n", event);
        break;
    }
    pthread_mutex_unlock(&uvc_ipc_info.mutex);
    if (event != UVC_IPC_EVENT_RET_TRANSPORT_BUF)
        LOG_INFO("exit uvc_ipc_event event:%s\n", shm_meg_name[event - 1].c_str());

}

extern "C" void uvc_ipc_reconnect(void)//(struct UVC_IPC_INFO *info)
{
    if (uvc_ipc_info.shm_control && uvc_ipc_info.stop == false) {
        LOG_INFO("aiserver died, uvc reconnect to aiserver and send last info\n");
        uvc_ipc_info.shm_control->stopRecvMessage(); //clear the recv data
        uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_STOP, NULL);
        uvc_ipc_info.shm_control->ShmUVCDrmRelease();
        uvc_ipc_info.shm_control->startRecvMessage();
        uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_CONFIG_CAMERA, &uvc_ipc_info.camera);
        uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_START, NULL);
    } else {
        LOG_INFO("aiserver died, uvc status is stop,no need do anything\n");
    }
}

void ProcessRecvUVCMessage(void *opaque)
{
    prctl(PR_SET_NAME, "uvc_ipc_recv_msg_thread");
    ShmUVCController *controller = (ShmUVCController *)opaque;
    controller->recvUVCMessageLoop();
}

#if UVC_IPC_DYNAMIC_DEBUG_ON
void ProcessDebug(void *opaque)
{
    prctl(PR_SET_NAME, "uvc_ipc_debug_thread");
    ShmUVCController *controller = (ShmUVCController *)opaque;
    controller->uvcIPCDebugLoop();
}
#endif


ShmUVCController::ShmUVCController()
{
    memset(&uvc_ipc_info, 0, sizeof(uvc_ipc_info));
    pthread_mutex_init(&uvc_ipc_info.mutex, NULL);
    uvc_ipc_info.stop = true;
#if UVC_SENDBUFF_USE_INIT_ALLOC
    MediaBufferInfo *send_bufferinfo = new MediaBufferInfo;
    send_message.set_allocated_buffer_info(send_bufferinfo);
#endif

#if UVC_IPC_DYNAMIC_DEBUG_ON
    debugLooping = true;
    debugThread = new std::thread(ProcessDebug, this);
#endif
    initialize();
}

ShmUVCController::~ShmUVCController()
{
    if (drmFd >= 0)
    {
        drm_close(drmFd);
        drmFd = -1;
    }
#if UVC_IPC_DYNAMIC_DEBUG_ON
    debugLooping = false;
    if (debugThread)
    {
        debugThread->join();
        delete debugThread;
        debugThread = nullptr;
    }
#endif
    pthread_mutex_destroy(&uvc_ipc_info.mutex);
    uvc_ipc_reinit();
}

void ShmUVCController::ShmUVCDrmRelease()
{
    int free_count = 0;
    for (std::map<int, DrmBuffMap>::iterator iter = drm_info.begin(); iter != drm_info.end(); ++iter)
    {
        ++free_count;
        if (iter->second.buf)
            drm_unmap_buffer(iter->second.buf, iter->second.size);
        if (iter->second.buf_fd)
            close(iter->second.buf_fd);
        if (iter->second.handle)
            drm_free(drmFd, iter->second.handle);
        LOG_DEBUG("drm_free count:%d\n", free_count);
    }
    drm_info.clear();
}

void ShmUVCController::initialize()
{
    recvLooping = false;
    recvThread = NULL;
#ifdef USE_RK_AISERVER
    shmc::SetLogHandler(shmc::kDebug, [](shmc::LogLevel lv, const char *s)
    {
        printf("[%d] %s\n", lv, s);
    });

    shmWriteQueue.InitForWrite(kShmUVCWriteKey, kQueueBufSize);
    //assert(shmWriteReadQueue.InitForWrite(kShmUVCReadKey, kQueueBufSize));
    shmWriteReadQueue.InitForWrite(kShmUVCReadKey, kQueueBufSize);
    shmReadQueue.InitForRead(kShmUVCReadKey);
    LOG_DEBUG("ShmUVCController init\n");
#endif
    drmFd = drm_open();
}

void ShmUVCController::startRecvMessage()
{
    LOG_DEBUG("start recv message in\n");
#if UVC_IPC_DYNAMIC_DEBUG_ON
    gettimeofday(&ipc_enter_time, NULL);
    gettimeofday(&isp_enter_time, NULL);
#endif
    recvLooping = true;
    norecv_err_count = 0;
    norecv_count = 0;
    abandon_count = 0;
    send_count = 0;
    recv_count = 0;
    set_buf_count = 0;
    isp_buf_count = 0;
    recvThread = new std::thread(ProcessRecvUVCMessage, this);
    if (!access("tmp/uvc_ipc_state", 0))
        system("rm /tmp/uvc_ipc_state");
    if (!access("/tmp/uvc_ipc_buffer", 0))
        system("rm /tmp/uvc_ipc_buffer");

    LOG_DEBUG("start recv message ok\n");
}

void ShmUVCController::clearRecvMessage()
{
    int ret = 0;
    int length = 0;
    std::string msg;

    std::lock_guard<std::mutex> lock(rQueueMtx);
    do
    {
        ret = shmReadQueue.Pop(&msg);
        length = msg.length();
        LOG_INFO("clear recv message(ret=%d, length=%d)\n", ret, length);
//      if (ret)
//          handleUVCMessage(msg); //test
        msg.clear();
    }
    while (ret && length > 0);
    //queue_r_.Reset();
}


void ShmUVCController::stopRecvMessage()
{
    LOG_DEBUG("stop recv message enter\n");

#if UVC_IPC_DYNAMIC_DEBUG_ON
    if (!access(UVC_IPC_DYNAMIC_DEBUG_ISP_STATE, 0))
        system("rm /tmp/uvc_isp_state");
#endif

    recvLooping = false;
    if (recvThread)
    {
        recvThread->join();
        delete recvThread;
        recvThread = nullptr;
    }

    LOG_INFO("stop recv message ok\n");
    clearRecvMessage();
    //queue_r_.Reset();
}

#if UVC_IPC_DYNAMIC_DEBUG_ON
void ShmUVCController::uvcIPCDebugLoop()
{
    LOG_DEBUG("enter\n");
    bool eptz = false;
    int set_eptz = 0;
    while (debugLooping)
    {
        sleep(1);
#if UVC_IPC_DYNAMIC_DEBUG_ON
        if (!access(UVC_IPC_DYNAMIC_DEBUG_STATE, 0))
        {
            LOG_INFO("send state:%d,recv state:%d\n", send_state, recv_state);
            LOG_INFO("send_seq:%d, recv_seq:%d send_count:%d, recv_count:%d\n",
                      send_seq, recv_seq, send_count, recv_count);
        }
        if (!access(UVC_IPC_DYNAMIC_DEBUG_EPTZ, 0) && eptz == false)
        {
            LOG_INFO("oepn eptz\n");
            eptz = true;
            set_eptz = 1;
            uvc_ipc_event(UVC_IPC_EVENT_ENABLE_ETPTZ, (void *)&set_eptz);
        }
        else if (access(UVC_IPC_DYNAMIC_DEBUG_EPTZ, 0) && eptz == true)
        {
            LOG_INFO("close eptz\n");
            eptz = false;
            set_eptz = 0;
            uvc_ipc_event(UVC_IPC_EVENT_ENABLE_ETPTZ, (void *)&set_eptz);
        }
        if (!access(UVC_IPC_DYNAMIC_DEBUG_ISP_STATE, 0))
        {
            int fd = -1, ret = -1, handle_fd = -1, size = 0;
            char *buffer;
            unsigned int handle = 0;
            int isp_state = 0, y, uv;
            struct MPP_ENC_INFO enc_info;
            struct timespec now_tm = {0, 0};

            LOG_INFO("send fixed picture to uvc instead isp enter\n");
            std::lock_guard<std::mutex> lock(rQueueMtx);
            fd = drm_open();
            if (fd < 0) {
                LOG_ERROR("drm open fail\n");
                goto DRM_FAIL;
            }
            size = MPP_ALIGN(width, 16) * MPP_ALIGN(height, 16) * 3 / 2;
            ret = drm_alloc(fd, size, 16, &handle, 0);
            if (ret) {
                LOG_ERROR("drm alloc fail\n");
                goto DRM_FAIL;
            }
            ret = drm_handle_to_fd(fd, handle, &handle_fd, 0);
            if (ret) {
                LOG_ERROR("drm_handle_to_fd fail\n");
                goto DRM_FAIL;
            }
            buffer = (char *)drm_map_buffer(fd, handle, size);
            if (!buffer)
            {
                LOG_ERROR("drm map buffer fail.\n");
                goto DRM_FAIL;
            }
            enc_info.fd = handle_fd;
            enc_info.size = size;

            while (!access(UVC_IPC_DYNAMIC_DEBUG_ISP_STATE, 0)) {
                enc_info.seq = isp_state;
                clock_gettime(CLOCK_MONOTONIC, &now_tm);
                enc_info.pts = now_tm.tv_sec * 1000000LL + now_tm.tv_nsec / 1000;

                isp_state ++;
                if (isp_state % 2) {
                    y = width * height / 4;
                    memset(buffer, 128, y);
                    memset(buffer + y, 64, y);
                    memset(buffer + y * 2, 128, y);
                    memset(buffer + y * 3, 192, y);
                    uv = width * height / 8;
                    memset(buffer + y * 4, 0, uv);
                    memset(buffer + y * 4 + uv, 64, uv);
                    memset(buffer + y * 4 + uv * 2, 128, uv);
                    memset(buffer + y * 4 + uv * 3, 192, uv);
                } else {
                    y = width * height / 4;
                    memset(buffer, 64, y);
                    memset(buffer + y, 128, y);
                    memset(buffer + y * 2, 192, y);
                    memset(buffer + y * 3, 128, y);
                    uv = width * height / 8;
                    memset(buffer + y * 4, 192, uv);
                    memset(buffer + y * 4 + uv, 128, uv);
                    memset(buffer + y * 4 + uv * 2, 64, uv);
                    memset(buffer + y * 4 + uv * 3, 0, uv);
                }
                uvc_read_camera_buffer(buffer, &enc_info, NULL, 0);
                usleep(100 * 1000);
            }
DRM_FAIL:
            drm_unmap_buffer(buffer, size);
            if (handle_fd >= 0)
                close(handle_fd);
            if (fd >=0 && handle > 0)
                drm_free(fd, handle);
            if (fd >= 0)
                drm_close(fd);
            if (!access(UVC_IPC_DYNAMIC_DEBUG_ISP_STATE, 0))
                system("rm /tmp/uvc_isp_state");
            LOG_INFO("send fixed picture to uvc instead isp exit\n");
        }
#endif
    }
    LOG_DEBUG("exit \n");
}
#endif

void ShmUVCController::recvUVCMessageLoop()
{
    int ret = 0;
    LOG_DEBUG("recv uvc message thread enter\n");
    while (recvLooping)
    {
        std::string msg;
        std::lock_guard<std::mutex> lock(rQueueMtx);

        ret = shmReadQueue.Pop(&msg);
        if (ret)
        {
            //LOG_INFO("recv uvc message = %s \n", msg.c_str());
            handleUVCMessage(msg);
            msg.clear();
            norecv_count = 0;
        }
        else
        {
            usleep(1 * 1000);
            ++ norecv_count;
            if (norecv_count >= 5000) // 5s not recv data have error
            {
                ++ norecv_err_count;
                LOG_ERROR("%d ms not recv data, count up to %d, maybe isp err(uvc not get raw). stat:%d,%d seq:%d,%d\n",
                           norecv_count * 1, norecv_err_count,
                           send_state, recv_state,
                           send_seq, recv_seq);
                if (norecv_err_count == 1)
                {
                    system("touch /tmp/uvc_ipc_buffer"); // for check uvc_ipc_buffer
                    LOG_INFO("test: touch /tmp/uvc_ipc_buffer ok!\n");
                    system("touch /tmp/uvc_ipc_state"); // for check uvc_ipc_state
                    LOG_INFO("test: touch /tmp/uvc_ipc_state ok!\n");
                }
                norecv_count = 0;
            }
        }
    }
    LOG_DEBUG("recv uvc message thread end\n");
}

void ShmUVCController::handleUVCMessage(std::string &msg)
{
    int msgType = 0;
    UVCMessage message;

    message.ParseFromString(msg);
    msgType = message.msg_type();
    if (msgType == MSG_UVC_TRANSPORT_BUF)  // UVC Buffer
    {
        MediaBufferInfo bufferInfo = message.buffer_info();
        recvUVCBuffer(&bufferInfo);
        //LOG_INFO("recv uvc buffer message\n");
    }
    else
    {
        LOG_WARN("recv uvc unknown message\n");
    }
}

void ShmUVCController::recvUVCBuffer(MediaBufferInfo *bufferInfo)
{
    int ret = 0;
    int buf_fd;
    unsigned int handle;
    int drm_size;
    char *buf = NULL;
    int32_t name = bufferInfo->id();
    int32_t buf_size = bufferInfo->size();
    int64_t privData = bufferInfo->priv_data();
    int64_t pts = bufferInfo->pts();
    int32_t seq = bufferInfo->seq();
    struct SendBufferInfo send_info;
    //std::map<int, DrmBuffMap> temp_map;
    struct DrmBuffMap drm_map;
    int map_count;
    bool has_map = false;
    send_info.id = name;
    send_info.size = bufferInfo->size();
    send_info.fd = bufferInfo->fd();
    send_info.handle = bufferInfo->handle();
    send_info.data = bufferInfo->data();
    send_info.priv_data = privData;
    send_info.seq = seq;
    recv_count ++;
    int count = 0;
    struct MPP_ENC_INFO enc_info;
#if UVC_DYNAMIC_DEBUG_USE_TIME
    if (!access(UVC_DYNAMIC_DEBUG_USE_TIME_CHECK, 0))
    {
        int64_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 - pts;
        //pts = now_time_us;//for test
        LOG_INFO("isp->aiserver->ipc seq: %d latency time:%lld us, %lld ms\n",seq, use_time_us, use_time_us / 1000);
    }
#endif

#if UVC_IPC_DYNAMIC_DEBUG_ON
    recv_state = UVC_IPC_STATE_RECV_ENTER;
    recv_seq = seq;
#endif
#if UVC_IPC_DYNAMIC_DEBUG_ON
    if (!access(UVC_IPC_DYNAMIC_DEBUG_FPS, 0))
    {
        ++frm;
        if (frm == 100) {
            struct timeval now_time;
            gettimeofday(&now_time, NULL);
            int64_t use_timems = (now_time.tv_sec * 1000 + now_time.tv_usec / 1000) -
                                  (ipc_enter_time.tv_sec * 1000 + ipc_enter_time.tv_usec / 1000);
            ipc_enter_time.tv_sec = now_time.tv_sec;
            ipc_enter_time.tv_usec = now_time.tv_usec;
            fps = (1000.0 * frm) / use_timems;
            frm = 0;
            LOG_INFO("ipc recv fps:%0.1f\n", fps);
        }
    }
#endif

    for (std::map<int, DrmBuffMap>::iterator iter = drm_info.begin(); iter != drm_info.end(); ++iter)
    {
        count ++;
        if (name == iter->second.id)
        {
            has_map = true;
#if RK_MPP_DYNAMIC_DEBUG_ON
            if (!access(RK_MPP_DYNAMIC_DEBUG_IN_CHECK, 0) || (encode_type == UVC_IPC_ENC_YUV))
#else
            if (encode_type == UVC_IPC_ENC_YUV)
#endif
            {

                if (!iter->second.buf)
                {
                    iter->second.buf = (char *)drm_map_buffer(drmFd, iter->second.handle, iter->second.size);
                }
            }

            buf = iter->second.buf;
            buf_fd = iter->second.buf_fd;
            break;
        }
    }
//  LOG_INFO("count=%d drm_info.size()=%d\n",count, drm_info.size());

    if (has_map == false)
    {
        drm_get_info_from_name(drmFd, name, &handle, &drm_size);
        ret = drm_handle_to_fd(drmFd, handle, &buf_fd, 0);
        if (ret)
        {
            LOG_ERROR("drm_handle_to_fd fail\n");
            return;
        }
#if RK_MPP_DYNAMIC_DEBUG_ON
        if (!access(RK_MPP_DYNAMIC_DEBUG_IN_CHECK, 0) || (encode_type == UVC_IPC_ENC_YUV))
#else
        if (encode_type == UVC_IPC_ENC_YUV)
#endif
        {
            buf = (char *)drm_map_buffer(drmFd, handle, buf_size);
        }

        drm_map.buf = buf;
        drm_map.id = name;
        drm_map.size = buf_size;
        drm_map.handle = handle;
        drm_map.buf_fd = buf_fd;
        map_count = drm_info.size() + 1;
        isp_buf_count ++;
        drm_info.insert(std::map<int, DrmBuffMap>::value_type(map_count, drm_map));
        LOG_INFO("new drm_map count=%d name=%d,buf_fd=%d buf_size=%d drm_size=%d priv=0x%llx\n",
                 map_count, name, buf_fd, buf_size, drm_size, privData);
    }
#if UVC_IPC_DYNAMIC_DEBUG_ON
    recv_state = UVC_IPC_STATE_RECV_ENC_ENTER;
#endif
    enc_info.fd = buf_fd;
    enc_info.size = nv12_size;
    enc_info.pts = pts;
    enc_info.seq = seq;
#if RK_MPP_DYNAMIC_DEBUG_ON
    if (!access(UVC_IPC_DYNAMIC_DEBUG_ISP_FPS, 0))
    {
        ++isp_frm;
        if (isp_frm == 100) {
            struct timeval now_time;
            gettimeofday(&now_time, NULL);
            int64_t use_timems = (now_time.tv_sec * 1000 + now_time.tv_usec / 1000) -
                                  (isp_enter_time.tv_sec * 1000 + isp_enter_time.tv_usec / 1000);
            isp_enter_time.tv_sec = now_time.tv_sec;
            isp_enter_time.tv_usec = now_time.tv_usec;
            fps = (1000.0 * isp_frm) / use_timems;
            isp_frm = 0;
            LOG_INFO("isp recv fps:%0.1f\n", fps);
        }
    }
    else
#endif
    {
#if UVC_ABANDON_FRM_COUNT
        if (abandon_count < UVC_ABANDON_FRM_COUNT)
        {
            ++ abandon_count;
            LOG_INFO("abandon frm, count=%d\n", abandon_count);
        }
        else
#endif
        {
            uvc_read_camera_buffer(buf, &enc_info,
                                   NULL, 0);
        }
    }
#if UVC_IPC_DYNAMIC_DEBUG_ON
    recv_state = UVC_IPC_STATE_RECV_ENC_EXIT;
#endif
    //uvc_ipc_event(UVC_IPC_EVENT_RET_TRANSPORT_BUF, (void *)&send_info); //not call uvc_ipc_event here,it will be dead lock
    if (!set_buf_count || (set_buf_count && isp_buf_count <= set_buf_count))
        uvc_ipc_info.shm_control->sendUVCBuffer(MSG_UVC_TRANSPORT_BUF, (void *)&send_info);
    else { // for mjpeg_fps 4k solution
        isp_buf_count -= 1;
        LOG_INFO("save isp buf count:%d priv=0x%llx\n", drm_info.size() - isp_buf_count, privData);
    }
#if UVC_IPC_DYNAMIC_DEBUG_ON
    recv_state = UVC_IPC_STATE_RECV_EXIT;
#endif
}

void ShmUVCController::sendUVCBuffer(enum ShmUVCMessageType event, void *data)
{
    std::string sendbuf;
#if UVC_IPC_DYNAMIC_DEBUG_ON
    send_state = UVC_IPC_STATE_SEND_ENTER;
#endif
    std::lock_guard<std::mutex> lock(wQueueMtx);
#if UVC_IPC_DYNAMIC_DEBUG_ON
    send_state = UVC_IPC_STATE_SEND_ENTER_UNLOCK;
#endif
    switch (event)
    {
    case MSG_UVC_START:
    {
        UVCMessage message;
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        if (encode_type == UVC_IPC_ENC_MJPEG_LOW_LATENCY) {
            set_buf_count = 2;
        }
    }
    break;
    case MSG_UVC_STOP:
    {
        UVCMessage message;
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
    }
    break;
    case MSG_UVC_ENABLE_ETPTZ:
    {
        UVCMessage message;
        MethodParams *method_param = new MethodParams;
        int *enable;
        if (data == NULL)
            *enable = 0;
        else
            enable = (int *)data;
        method_param->set_i32_p(*enable);
        message.set_allocated_method_params(method_param);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        LOG_INFO("send uvc eptz:%d \n", *enable);
        uvc_ipc_info.enable_eptz = *enable;
    }
    break;
    case MSG_UVC_SET_ZOOM:
    {
        UVCMessage message;
        MethodParams *method_param = new MethodParams;
        int *int_zoom = (int *)data;
        float zoom = (float)(*int_zoom / 10.0);
        //MethodParams method_param =
        method_param->set_flo_p(zoom);
        message.set_allocated_method_params(method_param);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        LOG_INFO("send uvc zoom:%f \n", zoom);
        uvc_ipc_info.zoom = *int_zoom;
    }
    break;
    case MSG_UVC_TRANSPORT_BUF:
    {
#if UVC_SENDBUFF_USE_INIT_ALLOC
        MediaBufferInfo *bufferInfo = &const_cast<MediaBufferInfo &>(send_message.buffer_info());
        struct SendBufferInfo *info = (struct SendBufferInfo *)data;
        bufferInfo->set_id(info->id);
        bufferInfo->set_size(info->size);
        bufferInfo->set_fd(info->fd);
        bufferInfo->set_handle(info->handle);
        bufferInfo->set_data(info->data);
        bufferInfo->set_priv_data(info->priv_data);
        bufferInfo->set_seq(info->seq);
        send_seq = info->seq;
        send_count ++;

        send_message.set_msg_type(event);
        send_message.set_msg_name("uvcbuffer");
        send_message.SerializeToString(&sendbuf);
        send_message.ParseFromString(sendbuf);
#else
        UVCMessage message;
        MediaBufferInfo *bufferInfo = new MediaBufferInfo;
        struct SendBufferInfo *info = (struct SendBufferInfo *)data;
        bufferInfo->set_id(info->id);
        bufferInfo->set_size(info->size);
        bufferInfo->set_fd(info->fd);
        bufferInfo->set_handle(info->handle);
        bufferInfo->set_data(info->data);
        bufferInfo->set_priv_data(info->priv_data);

        message.set_allocated_buffer_info(bufferInfo);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
#endif
    }
    break;
    case MSG_UVC_CONFIG_CAMERA:
    {
        UVCMessage message;
        StreamInfo *streamInfo = new StreamInfo;
        struct CAMERA_INFO *info = (struct CAMERA_INFO *)data;
        width = info->width;
        height = info->height;
        nv12_size = width * height * 3 / 2;
        streamInfo->set_width(info->width);
        streamInfo->set_height(info->height);
        streamInfo->set_vir_width(info->vir_width);
        streamInfo->set_vir_height(info->vir_height);
        streamInfo->set_buf_size(info->buf_size);
        streamInfo->set_range(info->range);
        encode_type = info->encode_type;
        uvc_fps_set = info->uvc_fps_set;
        message.set_allocated_stream_info(streamInfo);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        LOG_INFO("send uvc config camera. \
width:%d,height:%d,vir_width=%d,vir_height=%d,buf_size=%d,range=%d,enc=%d,fps=%d\n",
                 info->width, info->height, info->vir_width, info->vir_height,
                 info->buf_size, info->range, encode_type, uvc_fps_set);
        memcpy(&uvc_ipc_info.camera, info, sizeof(struct CAMERA_INFO));
    }
    break;
    case MSG_UVC_SET_EPTZ_PAN:
    {
        UVCMessage message;
        MethodParams *method_param = new MethodParams;
        int *pan;
        if (data == NULL)
            *pan = 0;
        else
            pan = (int *)data;
        method_param->set_i32_p(*pan);
        message.set_allocated_method_params(method_param);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        LOG_INFO("send uvc eptz pan:%d \n", *pan);
        uvc_ipc_info.eptz_pan = *pan;
    }
    break;
    case MSG_UVC_SET_EPTZ_TILT:
    {
        UVCMessage message;
        MethodParams *method_param = new MethodParams;
        int *tilt;
        if (data == NULL)
            *tilt = 0;
        else
            tilt = (int *)data;
        method_param->set_i32_p(*tilt);
        message.set_allocated_method_params(method_param);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        LOG_INFO("send uvc eptz tilt:%d \n", *tilt);
        uvc_ipc_info.eptz_tilt = *tilt;
    }
    break;
    case MSG_UVC_ENABLE_BYPASS:
    {
        UVCMessage message;
        MethodParams *method_param = new MethodParams;
        int *enable;
        if (data == NULL)
            *enable = 0;
        else
            enable = (int *)data;
        method_param->set_i32_p(*enable);
        message.set_allocated_method_params(method_param);
        message.set_msg_type(event);
        message.set_msg_name("uvcbuffer");
        message.SerializeToString(&sendbuf);
        message.ParseFromString(sendbuf);
        LOG_INFO("send uvc use bypass:%d \n", *enable);
    }
    break;
    default :
        break;
    }
#if UVC_IPC_DYNAMIC_DEBUG_ON
    send_state = UVC_IPC_STATE_SEND_READY;
#endif
    shmWriteQueue.Push(sendbuf);
#if UVC_IPC_DYNAMIC_DEBUG_ON
    send_state = UVC_IPC_STATE_SEND_EXIT;
#endif
}

} // namespace ShmControl