// 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 "shm_control_uvc.h"
|
#include "logger/log.h"
|
#include "drm_helper.h"
|
#include "RTVideoFrame.h"
|
|
#ifdef LOG_TAG
|
#undef LOG_TAG
|
#endif
|
#define LOG_TAG "shm_control_uvc"
|
|
namespace rockchip {
|
namespace aiserver {
|
|
void ProcessRecvUVCMessage(void *opaque) {
|
prctl(PR_SET_NAME, "aiuvc_recv_msg_thread");
|
ShmUVCController* controller = (ShmUVCController *)opaque;
|
controller->recvUVCMessageLoop();
|
}
|
|
ShmUVCController::ShmUVCController() {
|
initialize();
|
}
|
|
ShmUVCController::~ShmUVCController() {
|
#if UVC_DYNAMIC_DEBUG
|
debugLooping = false;
|
if (debugThread)
|
{
|
debugThread->join();
|
delete debugThread;
|
debugThread = nullptr;
|
}
|
#endif
|
if (drmFd >= 0) {
|
drm_close(drmFd);
|
drmFd = -1;
|
}
|
}
|
|
#if UVC_DYNAMIC_DEBUG
|
void ProcessDebug(void *opaque)
|
{
|
prctl(PR_SET_NAME, "shm_uvc_debug_thread");
|
ShmUVCController *controller = (ShmUVCController *)opaque;
|
controller->debugLoop();
|
}
|
|
void ShmUVCController::debugLoop()
|
{
|
LOG_INFO("enter\n");
|
while (debugLooping)
|
{
|
sleep(1);
|
if (!access(UVC_IPC_DYNAMIC_DEBUG_STATE, 0))
|
{
|
LOG_INFO("send_seq:%d, recv_seq:%d send_count:%d, recv_count:%d\n",
|
send_seq, recv_seq, send_count, recv_count);
|
}
|
}
|
LOG_INFO("exit \n");
|
}
|
#endif
|
|
void ShmUVCController::initialize() {
|
recvLooping = false;
|
uvcRunning = false;
|
cameraWidth = -1;
|
cameraHeight = -1;
|
bool shmRet = false;
|
#ifdef ENABLE_SHM_SERVER
|
shmc::SetLogHandler(shmc::kDebug, [](shmc::LogLevel lv, const char *s) {
|
LOG_INFO("[%d] %s\n", lv, s);
|
});
|
shmRet = shmWriteQueue.InitForWrite(kShmUVCWriteKey, kUVCQueueBufSize);
|
LOG_INFO("shmWriteQueue InitForWrite(ret=%d)\n", shmRet);
|
|
shmRet = shmReadWriteQueue.InitForWrite(kShmUVCReadKey, kUVCQueueBufSize);
|
shmRet = shmReadQueue.InitForRead(kShmUVCReadKey);
|
LOG_INFO("shmReadQueue InitForRead(ret=%d)\n", shmRet);
|
#endif
|
#if UVC_DYNAMIC_DEBUG
|
debugLooping = true;
|
debugThread = new std::thread(ProcessDebug, this);
|
#endif
|
|
drmFd = drm_open();
|
}
|
|
void ShmUVCController::setControlListener(RTGraphListener* listener) {
|
graphListener = listener;
|
}
|
|
void ShmUVCController::reset() {
|
int ret = 0;
|
int length = 0;
|
std::string msg;
|
|
do {
|
std::lock_guard<std::mutex> lock(readQueueMtx);
|
ret = shmReadQueue.Pop(&msg);
|
length = msg.length();
|
LOG_INFO("stop recv message(ret=%d, length=%d)\n", ret, length);
|
msg.clear();
|
} while(ret && length > 0);
|
//queue_r_.Reset();
|
}
|
|
void ShmUVCController::startRecvMessage() {
|
recvLooping = true;
|
recvThread = new std::thread(ProcessRecvUVCMessage, this);
|
}
|
|
void ShmUVCController::stopRecvMessage()
|
{
|
recvLooping = false;
|
if (recvThread) {
|
recvThread->join();
|
delete recvThread;
|
recvThread = nullptr;
|
}
|
|
reset();
|
}
|
|
void ShmUVCController::recvUVCMessageLoop() {
|
int ret = 0;
|
while (recvLooping) {
|
std::string msg;
|
|
do {
|
std::lock_guard<std::mutex> lock(readQueueMtx);
|
ret = shmReadQueue.Pop(&msg);
|
} while (0);
|
|
if (ret) {
|
LOG_DEBUG("recv uvc message = %s\n", msg.c_str());
|
handleUVCMessage(msg);
|
msg.clear();
|
} else {
|
usleep(5*1000);
|
}
|
}
|
LOG_INFO("recv uvc message thread end\n");
|
}
|
|
void ShmUVCController::handleUVCMessage(std::string &msg) {
|
int msgType = 0;
|
UVCMessage message;
|
|
message.ParseFromString(msg);
|
msgType = message.msg_type();
|
|
switch(msgType) {
|
case MSG_UVC_START: {
|
doStartUVC();
|
break;
|
}
|
case MSG_UVC_STOP: {
|
doStopUVC();
|
break;
|
}
|
case MSG_UVC_ENABLE_ETPTZ: {
|
MethodParams methodParams = message.method_params();
|
int enabled = methodParams.i32_p();
|
graphListener->setEPTZ(AI_UVC_EPTZ_AUTO, enabled);
|
break;
|
}
|
case MSG_UVC_SET_ZOOM: {
|
MethodParams methodParams = message.method_params();
|
float zoomVal = methodParams.flo_p();
|
graphListener->setZoom(zoomVal);
|
break;
|
}
|
case MSG_UVC_TRANSPORT_BUF: {
|
MediaBufferInfo bufferInfo = message.buffer_info();
|
doRecvUVCBuffer(&bufferInfo);
|
LOG_DEBUG("recv uvc buffer message\n");
|
break;
|
}
|
case MSG_UVC_CONFIG_CAMERA: {
|
StreamInfo streamInfo = message.stream_info();
|
doUpdateCameraParams(&streamInfo);
|
break;
|
}
|
case MSG_UVC_SET_EPTZ_PAN: {
|
MethodParams methodParams = message.method_params();
|
int pan = methodParams.i32_p();
|
graphListener->setEPTZ(AI_UVC_EPTZ_PAN, pan);
|
break;
|
}
|
case MSG_UVC_SET_EPTZ_TILT: {
|
MethodParams methodParams = message.method_params();
|
int tilt = methodParams.i32_p();
|
graphListener->setEPTZ(AI_UVC_EPTZ_TILT, tilt);
|
break;
|
}
|
case MSG_UVC_ENABLE_BYPASS: {
|
MethodParams methodParams = message.method_params();
|
int enabled = methodParams.i32_p();
|
graphListener->setEPTZ(AI_UVC_BYPASS_LINK, enabled);
|
break;
|
}
|
default:
|
LOG_ERROR("recv uvc unknown message\n");
|
break;
|
}
|
}
|
|
void ShmUVCController::doStartUVC() {
|
if (graphListener != nullptr) {
|
graphListener->start(RT_APP_UVC);
|
}
|
std::lock_guard<std::mutex> lock(opMutex);
|
uvcRunning = true;
|
#if UVC_DYNAMIC_DEBUG
|
send_count = 0;
|
recv_count = 0;
|
#endif
|
}
|
|
void ShmUVCController::doStopUVC() {
|
{
|
std::lock_guard<std::mutex> lock(opMutex);
|
uvcRunning = false;
|
LOG_INFO("clear uvc buffer after stopped\n");
|
clearUVCBuffer();
|
LOG_INFO("clear uvc buffer ok\n");
|
}
|
|
if (graphListener != nullptr) {
|
graphListener->stop(RT_APP_UVC);
|
}
|
}
|
|
void ShmUVCController::doRecvUVCBuffer(MediaBufferInfo* bufferInfo) {
|
std::lock_guard<std::mutex> lock(opMutex);
|
int32_t uniqueId = bufferInfo->id();
|
int64_t privData = bufferInfo->priv_data();
|
recv_seq = bufferInfo->seq();
|
recv_count ++;
|
|
RTMediaBuffer* mediaBuffer = (RTMediaBuffer *)privData;
|
|
int32_t found = 0;
|
std::list<RTMediaBuffer *>::iterator it;
|
for (it = bufList.begin(); it != bufList.end();) {
|
RTMediaBuffer *buf = *it;
|
if (buf == mediaBuffer) {
|
it = bufList.erase(it);
|
mediaBuffer->release();
|
found = 1;
|
break;
|
} else {
|
it++;
|
}
|
}
|
|
if (found) {
|
LOG_DEBUG("recv uvc buffer uniqueId %d, buffer 0x%llx\n", uniqueId, privData);
|
} else {
|
LOG_ERROR("recv invalid uvc buffer 0x%llx, seq:%d\n", privData, recv_seq);
|
}
|
}
|
|
void ShmUVCController::doUpdateCameraParams(StreamInfo* streamInfo) {
|
int forceClear = 0;
|
if (uvcRunning && (cameraWidth != streamInfo->width() ||
|
cameraHeight != streamInfo->height())) {
|
LOG_ERROR("config camera in unexpected state\n");
|
uvcRunning = false;
|
forceClear = 1;
|
std::lock_guard<std::mutex> lock(opMutex);
|
clearUVCBuffer();
|
}
|
|
RtMetaData cameraParams;
|
cameraParams.setInt32("opt_width", streamInfo->width());
|
cameraParams.setInt32("opt_height", streamInfo->height());
|
cameraParams.setInt32("opt_vir_width", streamInfo->vir_width());
|
cameraParams.setInt32("opt_vir_height", streamInfo->vir_height());
|
cameraParams.setInt32("node_buff_size", streamInfo->buf_size());
|
cameraParams.setInt32("opt_quantization", streamInfo->range());
|
cameraWidth = streamInfo->width();
|
cameraHeight = streamInfo->height();
|
graphListener->invoke(RT_APP_UVC, RT_ACTION_CONFIG_CAMERA, &cameraParams);
|
|
if (forceClear) {
|
uvcRunning = true;
|
}
|
}
|
|
void ShmUVCController::clearUVCBuffer() {
|
std::list<RTMediaBuffer *>::iterator it;
|
for (it = bufList.begin(); it != bufList.end();) {
|
RTMediaBuffer *buffer = *it;
|
it = bufList.erase(it);
|
if (buffer == nullptr) {
|
LOG_ERROR("uvc buffer null pointer\n");
|
} else {
|
LOG_ERROR("force release uniqueId %d, buffer 0x%x\n", buffer->getUniqueID(), buffer);
|
buffer->release();
|
}
|
}
|
}
|
|
void ShmUVCController::sendUVCBuffer(RTMediaBuffer* buffer) {
|
int64_t pts = 0;
|
int32_t seq = 0;
|
std::string sendbuf;
|
RTVideoFrame *pVFrame = reinterpret_vframe(buffer);
|
UVCMessage message;
|
if (buffer == nullptr) {
|
return;
|
}
|
if (pVFrame == nullptr) {
|
LOG_ERROR("buffer type is not video frame. release it.");
|
buffer->release();
|
return;
|
}
|
|
MediaBufferInfo *bufferInfo = new MediaBufferInfo();
|
message.set_allocated_buffer_info(bufferInfo);
|
//MediaBufferInfo bufferInfo = message.buffer_info();
|
|
bufferInfo->set_id(pVFrame->getUniqueID());
|
bufferInfo->set_size(pVFrame->getSize());
|
bufferInfo->set_fd(pVFrame->getFd());
|
bufferInfo->set_handle(pVFrame->getHandle());
|
bufferInfo->set_pts(pVFrame->getPts());
|
bufferInfo->set_data((int64_t)pVFrame->getData());
|
bufferInfo->set_priv_data((int64_t)pVFrame);
|
bufferInfo->set_seq(pVFrame->getSeq());
|
message.set_msg_type(MSG_UVC_TRANSPORT_BUF);
|
message.set_msg_name("uvcbuffer");
|
message.SerializeToString(&sendbuf);
|
message.ParseFromString(sendbuf);
|
|
std::lock_guard<std::mutex> lock(opMutex);
|
if (!uvcRunning) {
|
buffer->release();
|
return;
|
}
|
bufList.push_back(buffer);
|
shmWriteQueue.Push(sendbuf);
|
|
#if UVC_DYNAMIC_DEBUG
|
send_seq = pVFrame->getSeq();
|
send_count ++;
|
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 - pVFrame->getPts();
|
LOG_ERROR("isp->aiserver seq:%d latency time:%d us, %d ms\n", send_seq, use_time_us, use_time_us / 1000);
|
}
|
|
if (!access(UVC_DYNAMIC_DEBUG_IPC_BUFFER_CHECK, 0)) {
|
LOG_ERROR("send uvc buffer uniqueId %d, buffer 0x%llx\n", buffer->getUniqueID(), (int64_t)buffer);
|
}
|
#endif
|
|
}
|
|
}
|
}
|
