390 lines
13 KiB
C++
390 lines
13 KiB
C++
#include <signal.h>
|
|
#include <unistd.h>
|
|
|
|
#include <atomic>
|
|
#include <ctime>
|
|
#include <thread>
|
|
|
|
#include "camera_infohw.h"
|
|
#include "domain_tcp_client.h"
|
|
#include "rk-camera-module.h"
|
|
#if 0
|
|
#include "rkaiq_manager.h"
|
|
#endif
|
|
#include "rkaiq_protocol.h"
|
|
#include "rkaiq_socket.h"
|
|
#include "tcp_server.h"
|
|
#ifdef __ANDROID__
|
|
#include <rtspserver/RtspServer.h>
|
|
#include <cutils/properties.h>
|
|
#include "RtspServer.h"
|
|
#endif
|
|
|
|
#ifdef LOG_TAG
|
|
#undef LOG_TAG
|
|
#endif
|
|
#define LOG_TAG "aiqtool"
|
|
|
|
DomainTCPClient g_tcpClient;
|
|
struct ucred* g_aiqCred = nullptr;
|
|
std::atomic_bool quit{false};
|
|
std::atomic<int> g_app_run_mode(APP_RUN_STATUS_INIT);
|
|
int g_width = 1920;
|
|
int g_height = 1080;
|
|
int g_device_id = 0;
|
|
uint32_t g_mmapNumber = 4;
|
|
uint32_t g_offlineFrameRate = 10;
|
|
int g_rtsp_en = 0;
|
|
int g_rtsp_en_from_cmdarg = 0;
|
|
int g_allow_killapp = 0;
|
|
int g_cam_count = 0;
|
|
uint32_t g_sensorHdrMode = 0;
|
|
|
|
std::string g_stream_dev_name;
|
|
std::string iqfile;
|
|
std::string g_sensor_name;
|
|
|
|
std::shared_ptr<TCPServer> tcpServer = nullptr;
|
|
#if 0
|
|
std::shared_ptr<RKAiqToolManager> rkaiq_manager;
|
|
#endif
|
|
std::shared_ptr<RKAiqMedia> rkaiq_media;
|
|
|
|
void signal_handle(int sig)
|
|
{
|
|
quit.store(true, std::memory_order_release);
|
|
if (tcpServer != nullptr)
|
|
tcpServer->SaveExit();
|
|
|
|
RKAiqProtocol::Exit();
|
|
|
|
if (g_rtsp_en)
|
|
deinit_rtsp();
|
|
}
|
|
|
|
static int get_env(const char* name, int* value, int default_value)
|
|
{
|
|
char* ptr = getenv(name);
|
|
if (NULL == ptr) {
|
|
*value = default_value;
|
|
} else {
|
|
char* endptr;
|
|
int base = (ptr[0] == '0' && ptr[1] == 'x') ? (16) : (10);
|
|
errno = 0;
|
|
*value = strtoul(ptr, &endptr, base);
|
|
if (errno || (ptr == endptr)) {
|
|
errno = 0;
|
|
*value = default_value;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static const char short_options[] = "s:r:i:m:Dd:w:h:n:f:";
|
|
static const struct option long_options[] = {{"stream_dev", required_argument, NULL, 's'},
|
|
{"enable_rtsp", required_argument, NULL, 'r'},
|
|
{"iqfile", required_argument, NULL, 'i'},
|
|
{"mode", required_argument, NULL, 'm'},
|
|
{"width", no_argument, NULL, 'w'},
|
|
{"height", no_argument, NULL, 'h'},
|
|
{"device_id", required_argument, NULL, 'd'},
|
|
{"mmap_buffer", required_argument, NULL, 'n'},
|
|
{"frame_rate", required_argument, NULL, 'f'},
|
|
{"help", no_argument, NULL, 'h'},
|
|
{0, 0, 0, 0}};
|
|
|
|
static int parse_args(int argc, char** argv)
|
|
{
|
|
int ret = 0;
|
|
for (;;) {
|
|
int idx;
|
|
int c;
|
|
c = getopt_long(argc, argv, short_options, long_options, &idx);
|
|
if (-1 == c) {
|
|
break;
|
|
}
|
|
switch (c) {
|
|
case 0:
|
|
break;
|
|
case 's':
|
|
g_stream_dev_name = optarg;
|
|
break;
|
|
case 'r':
|
|
g_rtsp_en_from_cmdarg = atoi(optarg);
|
|
if (g_rtsp_en_from_cmdarg != 0 && g_rtsp_en_from_cmdarg != 1) {
|
|
LOG_ERROR("enable_rtsp arg|only equals 0 or 1\n");
|
|
ret = 1;
|
|
}
|
|
break;
|
|
case 'i':
|
|
iqfile = optarg;
|
|
break;
|
|
case 'm':
|
|
g_app_run_mode = atoi(optarg);
|
|
break;
|
|
case 'w':
|
|
g_width = atoi(optarg);
|
|
break;
|
|
case 'h':
|
|
g_height = atoi(optarg);
|
|
break;
|
|
case 'd':
|
|
g_device_id = atoi(optarg);
|
|
break;
|
|
case 'n':
|
|
g_mmapNumber = (uint32_t)atoi(optarg);
|
|
if (g_mmapNumber < 4 || g_mmapNumber > 200) {
|
|
g_mmapNumber = 4;
|
|
LOG_INFO("mmap Number out of range[4,200], use default 4\n");
|
|
}
|
|
break;
|
|
case 'f':
|
|
g_offlineFrameRate = (uint32_t)atoi(optarg);
|
|
if (g_offlineFrameRate < 1) {
|
|
g_offlineFrameRate = 1;
|
|
} else if (g_offlineFrameRate > 100) {
|
|
g_offlineFrameRate = 100;
|
|
}
|
|
LOG_INFO("set framerate:%u\n", g_offlineFrameRate);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (iqfile.empty()) {
|
|
#ifdef __ANDROID__
|
|
iqfile = "/vendor/etc/camera/rkisp2";
|
|
#else
|
|
iqfile = "/oem/etc/iqfiles";
|
|
#endif
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void RawCaptureinit()
|
|
{
|
|
struct capture_info cap_info;
|
|
media_info_t mi = rkaiq_media->GetMediaInfoT(g_device_id);
|
|
if (mi.cif.linked_sensor) {
|
|
cap_info.link = link_to_vicap;
|
|
strcpy(cap_info.sd_path.device_name, mi.cif.sensor_subdev_path.c_str());
|
|
strcpy(cap_info.cif_path.cif_video_path, mi.cif.mipi_id0.c_str());
|
|
cap_info.dev_name = cap_info.cif_path.cif_video_path;
|
|
} else if (mi.dvp.linked_sensor) {
|
|
cap_info.link = link_to_dvp;
|
|
strcpy(cap_info.sd_path.device_name, mi.dvp.sensor_subdev_path.c_str());
|
|
strcpy(cap_info.cif_path.cif_video_path, mi.dvp.dvp_id0.c_str());
|
|
cap_info.dev_name = cap_info.cif_path.cif_video_path;
|
|
} else {
|
|
cap_info.link = link_to_isp;
|
|
strcpy(cap_info.sd_path.device_name, mi.isp.sensor_subdev_path.c_str());
|
|
strcpy(cap_info.vd_path.isp_main_path, mi.isp.main_path.c_str());
|
|
cap_info.dev_name = cap_info.vd_path.isp_main_path;
|
|
}
|
|
strcpy(cap_info.vd_path.media_dev_path, mi.isp.media_dev_path.c_str());
|
|
strcpy(cap_info.vd_path.isp_sd_path, mi.isp.isp_dev_path.c_str());
|
|
if (mi.lens.module_lens_dev_name.length()) {
|
|
strcpy(cap_info.lens_path.lens_device_name, mi.lens.module_lens_dev_name.c_str());
|
|
} else {
|
|
cap_info.lens_path.lens_device_name[0] = '\0';
|
|
}
|
|
cap_info.dev_fd = -1;
|
|
cap_info.subdev_fd = -1;
|
|
cap_info.lensdev_fd = -1;
|
|
LOG_DEBUG("cap_info.link: %d \n", cap_info.link);
|
|
LOG_DEBUG("cap_info.dev_name: %s \n", cap_info.dev_name);
|
|
LOG_DEBUG("cap_info.isp_media_path: %s \n", cap_info.vd_path.media_dev_path);
|
|
LOG_DEBUG("cap_info.vd_path.isp_sd_path: %s \n", cap_info.vd_path.isp_sd_path);
|
|
LOG_DEBUG("cap_info.sd_path.device_name: %s \n", cap_info.sd_path.device_name);
|
|
LOG_DEBUG("cap_info.lens_path.lens_dev_name: %s \n", cap_info.lens_path.lens_device_name);
|
|
|
|
cap_info.io = IO_METHOD_MMAP;
|
|
cap_info.height = g_height;
|
|
cap_info.width = g_width;
|
|
// cap_info.format = v4l2_fourcc('B', 'G', '1', '2');
|
|
LOG_DEBUG("get ResW: %d ResH: %d\n", cap_info.width, cap_info.height);
|
|
|
|
//
|
|
int fd = device_open(cap_info.sd_path.device_name);
|
|
LOG_DEBUG("sensor subdev path: %s\n", cap_info.sd_path.device_name);
|
|
LOG_DEBUG("cap_info.subdev_fd: %d\n", fd);
|
|
if (fd < 0) {
|
|
LOG_ERROR("Open %s failed.\n", cap_info.sd_path.device_name);
|
|
} else {
|
|
rkmodule_hdr_cfg hdrCfg;
|
|
int ret = ioctl(fd, RKMODULE_GET_HDR_CFG, &hdrCfg);
|
|
if (ret > 0) {
|
|
g_sensorHdrMode = NO_HDR;
|
|
LOG_ERROR("Get sensor hdr mode failed, use default, No HDR\n");
|
|
} else {
|
|
g_sensorHdrMode = hdrCfg.hdr_mode;
|
|
LOG_INFO("Get sensor hdr mode:%u\n", g_sensorHdrMode);
|
|
}
|
|
}
|
|
close(fd);
|
|
if (mi.cif.linked_sensor) {
|
|
if (g_sensorHdrMode == NO_HDR) {
|
|
LOG_INFO("Get sensor mode: NO_HDR\n");
|
|
strcpy(cap_info.cif_path.cif_video_path, mi.cif.mipi_id0.c_str());
|
|
cap_info.dev_name = cap_info.cif_path.cif_video_path;
|
|
} else if (g_sensorHdrMode == HDR_X2) {
|
|
LOG_INFO("Get sensor mode: HDR_2\n");
|
|
strcpy(cap_info.cif_path.cif_video_path, mi.cif.mipi_id1.c_str());
|
|
cap_info.dev_name = cap_info.cif_path.cif_video_path;
|
|
} else if (g_sensorHdrMode == HDR_X3) {
|
|
LOG_INFO("Get sensor mode: HDR_3\n");
|
|
strcpy(cap_info.cif_path.cif_video_path, mi.cif.mipi_id2.c_str());
|
|
cap_info.dev_name = cap_info.cif_path.cif_video_path;
|
|
}
|
|
}
|
|
//
|
|
fd = open(cap_info.dev_name, O_RDWR, 0);
|
|
LOG_INFO("fd: %d\n", fd);
|
|
if (fd < 0) {
|
|
LOG_ERROR("Open dev %s failed.\n", cap_info.dev_name);
|
|
} else {
|
|
if (g_sensorHdrMode == NO_HDR) {
|
|
int value = CSI_LVDS_MEM_WORD_LOW_ALIGN;
|
|
int ret = ioctl(fd, RKCIF_CMD_SET_CSI_MEMORY_MODE, &value); // set to no compact
|
|
if (ret > 0) {
|
|
LOG_ERROR("set cif node %s compact mode failed.\n", cap_info.dev_name);
|
|
} else {
|
|
LOG_INFO("cif node %s set to no compact mode.\n", cap_info.dev_name);
|
|
}
|
|
} else {
|
|
LOG_INFO("cif node HDR mode, compact format as default.\n");
|
|
}
|
|
}
|
|
close(fd);
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
int ret = -1;
|
|
LOG_ERROR("#### AIQ tool server v2.0.6-20220215_145026 ####\n");
|
|
|
|
#ifdef _WIN32
|
|
signal(SIGINT, signal_handle);
|
|
signal(SIGQUIT, signal_handle);
|
|
signal(SIGTERM, signal_handle);
|
|
#else
|
|
sigset_t mask;
|
|
sigemptyset(&mask);
|
|
sigaddset(&mask, SIGINT);
|
|
sigaddset(&mask, SIGTERM);
|
|
sigaddset(&mask, SIGQUIT);
|
|
pthread_sigmask(SIG_BLOCK, &mask, NULL);
|
|
|
|
struct sigaction new_action, old_action;
|
|
new_action.sa_handler = signal_handle;
|
|
sigemptyset(&new_action.sa_mask);
|
|
new_action.sa_flags = 0;
|
|
sigaction(SIGINT, NULL, &old_action);
|
|
if (old_action.sa_handler != SIG_IGN)
|
|
sigaction(SIGINT, &new_action, NULL);
|
|
sigaction(SIGQUIT, NULL, &old_action);
|
|
if (old_action.sa_handler != SIG_IGN)
|
|
sigaction(SIGQUIT, &new_action, NULL);
|
|
sigaction(SIGTERM, NULL, &old_action);
|
|
if (old_action.sa_handler != SIG_IGN)
|
|
sigaction(SIGTERM, &new_action, NULL);
|
|
#endif
|
|
|
|
#ifdef __ANDROID__
|
|
char property_value[PROPERTY_VALUE_MAX] = {0};
|
|
property_get("persist.vendor.aiqtool.log", property_value, "5");
|
|
log_level = strtoull(property_value, nullptr, 16);
|
|
property_get("persist.vendor.aiqtool.killapp", property_value, "1");
|
|
g_allow_killapp = strtoull(property_value, nullptr, 16);
|
|
// property_get("persist.vendor.rkisp_no_read_back", property_value, "-1");
|
|
// readback = strtoull(property_value, nullptr, 16);
|
|
#else
|
|
get_env("rkaiq_tool_server_log_level", &log_level,
|
|
LOG_LEVEL_INFO); // LOG_LEVEL_ERROR LOG_LEVEL_WARN LOG_LEVEL_INFO LOG_LEVEL_DEBUG
|
|
get_env("rkaiq_tool_server_kill_app", &g_allow_killapp, 0);
|
|
#endif
|
|
|
|
if (parse_args(argc, argv) != 0) {
|
|
LOG_ERROR("Tool server args parse error.\n");
|
|
return 1;
|
|
}
|
|
|
|
LOG_DEBUG("iqfile cmd_parser.get %s\n", iqfile.c_str());
|
|
LOG_DEBUG("g_mode cmd_parser.get %d\n", g_app_run_mode.load());
|
|
LOG_DEBUG("g_width cmd_parser.get %d\n", g_width);
|
|
LOG_DEBUG("g_height cmd_parser.get %d\n", g_height);
|
|
LOG_DEBUG("g_device_id cmd_parser.get %d\n", g_device_id);
|
|
|
|
rkaiq_media = std::make_shared<RKAiqMedia>();
|
|
rkaiq_media->GetMediaInfo();
|
|
rkaiq_media->DumpMediaInfo();
|
|
|
|
LOG_DEBUG("================== %d =====================\n", g_app_run_mode.load());
|
|
system("mkdir -p /data/OfflineRAW && sync");
|
|
RawCaptureinit();
|
|
|
|
// return 0;
|
|
if (g_stream_dev_name.length() > 0) {
|
|
if (0 > access(g_stream_dev_name.c_str(), R_OK | W_OK)) {
|
|
LOG_DEBUG("Could not access streaming device\n");
|
|
if (g_rtsp_en_from_cmdarg == 1) {
|
|
g_rtsp_en = 0;
|
|
}
|
|
} else {
|
|
LOG_DEBUG("Access streaming device\n");
|
|
if (g_rtsp_en_from_cmdarg == 1) {
|
|
g_rtsp_en = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (g_rtsp_en && g_stream_dev_name.length() > 0) {
|
|
ret = RKAiqProtocol::DoChangeAppMode(APP_RUN_STATUS_STREAMING);
|
|
if (ret != 0) {
|
|
LOG_ERROR("Failed set mode to tunning mode, does app started?\n");
|
|
}
|
|
} else {
|
|
ret = RKAiqProtocol::DoChangeAppMode(APP_RUN_STATUS_TUNRING);
|
|
if (ret != 0) {
|
|
LOG_ERROR("Failed set mode to tunning mode, does app started?\n");
|
|
}
|
|
}
|
|
|
|
if (g_tcpClient.Setup("/tmp/UNIX.domain") == false) {
|
|
LOG_INFO("#### ToolServer connect AIQ failed ####\n");
|
|
// g_tcpClient.Close();
|
|
// return -1;
|
|
} else {
|
|
LOG_INFO("#### ToolServer connect AIQ success ####\n");
|
|
}
|
|
|
|
pthread_sigmask(SIG_UNBLOCK, &mask, NULL);
|
|
tcpServer = std::make_shared<TCPServer>();
|
|
tcpServer->RegisterRecvCallBack(RKAiqProtocol::HandlerTCPMessage);
|
|
tcpServer->Process(SERVER_PORT);
|
|
while (!quit.load() && !tcpServer->Exited()) {
|
|
pause();
|
|
// std::this_thread::sleep_for(std::chrono::milliseconds(1000));
|
|
}
|
|
|
|
tcpServer->SaveExit();
|
|
|
|
if (g_aiqCred != nullptr) {
|
|
delete g_aiqCred;
|
|
g_aiqCred = nullptr;
|
|
}
|
|
|
|
if (g_rtsp_en) {
|
|
system("pkill rkaiq_3A_server*");
|
|
deinit_rtsp();
|
|
}
|
|
|
|
#if 0
|
|
rkaiq_manager.reset();
|
|
rkaiq_manager = nullptr;
|
|
#endif
|
|
return 0;
|
|
}
|