/*
|
* 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 <stdio.h>
|
#include <stdbool.h>
|
#include <string.h>
|
#include <stdlib.h>
|
#include <fcntl.h>
|
#include <pthread.h>
|
#include "uvc_control.h"
|
#include "uvc_encode.h"
|
#include "uvc_video.h"
|
#include "uevent.h"
|
#include "uvc_log.h"
|
#include "uvc_configfs.h"
|
|
//#include "camera_control.h"
|
|
#define UVC_STREAMING_INTF_PATH "/sys/kernel/config/usb_gadget/rockchip/functions/uvc.gs6/streaming/bInterfaceNumber"
|
|
#define UVC_STREAMING_MAXPACKET_PATH "/sys/kernel/config/usb_gadget/rockchip/functions/uvc.gs6/streaming_maxpacket"
|
int enable_minilog;
|
int uvc_app_log_level;
|
int app_quit;
|
int uvc_depth_cnt;
|
int uvc_rgb_cnt;
|
|
|
static void (*camera_start_callback)(int fd, int width, int height, int fps, int format, int eptz);
|
static void (*camera_stop_callback)();
|
|
uvc_pu_control_callback_t uvc_pu_control_cb = NULL;
|
void register_uvc_pu_control_callback(uvc_pu_control_callback_t cb)
|
{
|
uvc_pu_control_cb = cb;
|
}
|
|
struct uvc_ctrl
|
{
|
int id;
|
bool start;
|
bool stop;
|
int width;
|
int height;
|
int fps;
|
int format;
|
int eptz;
|
int suspend;
|
struct uvc_function_config *fc;
|
};
|
|
static struct uvc_ctrl uvc_ctrl[3] =
|
{
|
{ -1, false, false, -1, -1, -1, 1, 0, 0, NULL},
|
{ -1, false, false, -1, -1, -1, 1, 0, 0, NULL},
|
{ -1, false, false, -1, -1, -1, 1, 0, 0, NULL}, //isp
|
};
|
|
struct uvc_encode uvc_enc;
|
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
|
static int uvc_streaming_intf = -1;
|
static int uvc_streaming_maxpacket = 1024;
|
|
bool uvc_encode_init_flag = false;
|
|
static pthread_t run_id = 0;
|
static bool uvc_restart = false;
|
static bool run_flag = true;
|
static uint32_t uvc_flags = UVC_CONTROL_CAMERA;
|
|
static pthread_mutex_t run_mutex = PTHREAD_MUTEX_INITIALIZER;
|
static pthread_cond_t run_cond = PTHREAD_COND_INITIALIZER;
|
static pthread_cond_t video_added = PTHREAD_COND_INITIALIZER;
|
|
static bool is_uvc_video(void *buf)
|
{
|
if (strstr(buf, "usb") || strstr(buf, "gadget"))
|
return true;
|
else
|
return false;
|
}
|
|
static void query_uvc_streaming_maxpacket(void)
|
{
|
int fd;
|
|
fd = open(UVC_STREAMING_MAXPACKET_PATH, O_RDONLY);
|
if (fd >= 0)
|
{
|
char intf[32] = {0};
|
read(fd, intf, sizeof(intf) - 1);
|
uvc_streaming_maxpacket = atoi(intf);
|
if(uvc_streaming_maxpacket < 1023)
|
uvc_streaming_maxpacket = 1024;
|
LOG_DEBUG("uvc_streaming_maxpacket = %d\n", uvc_streaming_maxpacket);
|
close(fd);
|
}
|
else
|
{
|
LOG_ERROR("open %s failed!\n", UVC_STREAMING_MAXPACKET_PATH);
|
}
|
}
|
|
int get_uvc_streaming_maxpacket(void)
|
{
|
return uvc_streaming_maxpacket;
|
}
|
|
static void query_uvc_streaming_intf(void)
|
{
|
int fd;
|
|
fd = open(UVC_STREAMING_INTF_PATH, O_RDONLY);
|
if (fd >= 0)
|
{
|
char intf[32] = {0};
|
read(fd, intf, sizeof(intf) - 1);
|
uvc_streaming_intf = atoi(intf);
|
LOG_DEBUG("uvc_streaming_intf = %d\n", uvc_streaming_intf);
|
close(fd);
|
}
|
else
|
{
|
LOG_ERROR("open %s failed!\n", UVC_STREAMING_INTF_PATH);
|
}
|
}
|
|
int get_uvc_streaming_intf(void)
|
{
|
return uvc_streaming_intf;
|
}
|
|
void uvc_control_start_setcallback(int (*callback)(int fd, int width, int height, int fps, int format, int eptz))
|
{
|
camera_start_callback = callback;
|
}
|
|
void uvc_control_stop_setcallback(void (*callback)())
|
{
|
camera_stop_callback = callback;
|
}
|
|
static void get_uvc_index_to_name(unsigned int index, char *name)
|
{
|
if (strstr(name, "depth") || strstr(name, "DEPTH") || strstr(name, "ir") || strstr(name, "IR")) {
|
uvc_depth_cnt = index;
|
LOG_DEBUG("uvc_depth_cnt = %d, name:%s\n",uvc_depth_cnt, name);
|
} else if (strstr(name, "rgb") || strstr(name, "RGB")) {
|
uvc_rgb_cnt = index;
|
LOG_DEBUG("uvc_rgb_cnt = %d, name:%s\n",uvc_rgb_cnt,name);
|
}
|
}
|
|
|
int check_uvc_video_id(void)
|
{
|
struct uvc_function_config *fc[CAM_MAX_NUM];
|
unsigned int i;
|
for (i = 0; i < CAM_MAX_NUM; i++) {
|
fc[i] = configfs_parse_uvc_function(i);
|
if (fc[i]) {
|
get_uvc_index_to_name(fc[i]->index, fc[i]->dev_name);
|
uvc_ctrl[i].id = fc[i]->video;
|
uvc_ctrl[i].fc = fc[i];
|
LOG_DEBUG("uvc_function_config fc->video:%d,fc->streaming.num_formats:%d",fc[i]->video,uvc_ctrl[i].fc->streaming.num_formats);
|
}
|
}
|
|
if (uvc_ctrl[0].id < 0 && uvc_ctrl[1].id < 0)
|
{
|
LOG_WARN("Please configure uvc...\n");
|
return -1;
|
}
|
//query_uvc_streaming_intf();
|
//query_uvc_streaming_maxpacket();
|
return 0;
|
}
|
|
void add_uvc_video()
|
{
|
if (uvc_ctrl[0].id >= 0)
|
{
|
uvc_video_id_add(uvc_ctrl[0].fc);
|
LOG_INFO("uvc_ctrl[0].id:%d, uvc_ctrl[0].fc->video:%d\n",uvc_ctrl[0].id,uvc_ctrl[0].fc->video);
|
}
|
|
if (uvc_ctrl[1].id >= 0) {
|
uvc_video_id_add(uvc_ctrl[1].fc);
|
}
|
}
|
|
void uvc_control_init(int width, int height, int fcc, int h265, unsigned int fps, int id)
|
{
|
pthread_mutex_lock(&lock);
|
memset(&uvc_enc, 0, sizeof(uvc_enc));
|
if (uvc_encode_init(&uvc_enc, width, height, fcc, h265, fps))
|
{
|
LOG_ERROR("%s fail!\n", __func__);
|
abort();
|
}
|
uvc_enc.video_id = id;
|
LOG_INFO("uvc_enc.video_id:%d",uvc_enc.video_id);
|
uvc_encode_init_flag = true;
|
pthread_mutex_unlock(&lock);
|
}
|
|
void uvc_control_inbuf_deinit()
|
{
|
pthread_mutex_lock(&lock);
|
if(uvc_encode_init_flag)
|
uvc_encode_inbuf_deinit(&uvc_enc);
|
pthread_mutex_unlock(&lock);
|
}
|
|
void uvc_control_exit()
|
{
|
pthread_mutex_lock(&lock);
|
if(uvc_encode_init_flag)
|
uvc_encode_exit(&uvc_enc);
|
memset(&uvc_enc, 0, sizeof(uvc_enc));
|
uvc_encode_init_flag = false;
|
pthread_mutex_unlock(&lock);
|
}
|
|
void uvc_read_camera_buffer(void *cam_buf, MPP_ENC_INFO_DEF *info,
|
void *extra_data, size_t extra_size)
|
{
|
#ifdef ENABLE_BUFFER_TIME_DEBUG
|
struct timeval buffer_time;
|
gettimeofday(&buffer_time, NULL);
|
LOG_ERROR("UVC READ CAMERA BUFFER TIME:%d.%d (s)",buffer_time.tv_sec,buffer_time.tv_usec);
|
#endif
|
pthread_mutex_lock(&lock);
|
if (info->size <= uvc_enc.width * uvc_enc.height * 2)
|
{
|
//uvc_enc.video_id = uvc_video_id_get(0);
|
uvc_enc.extra_data = extra_data;
|
uvc_enc.extra_size = extra_size;
|
uvc_encode_process(&uvc_enc, cam_buf, info);
|
}
|
else if (uvc_enc.width > 0 && uvc_enc.height > 0)
|
{
|
LOG_ERROR("%s: cam_size = %u, uvc_enc.width = %d, uvc_enc.height = %d\n",
|
__func__, info->size, uvc_enc.width, uvc_enc.height);
|
}
|
pthread_mutex_unlock(&lock);
|
}
|
|
static void uvc_control_wait(void)
|
{
|
pthread_mutex_lock(&run_mutex);
|
if (run_flag)
|
pthread_cond_wait(&run_cond, &run_mutex);
|
pthread_mutex_unlock(&run_mutex);
|
}
|
|
void uvc_control_signal(void)
|
{
|
pthread_mutex_lock(&run_mutex);
|
pthread_cond_signal(&run_cond);
|
pthread_mutex_unlock(&run_mutex);
|
}
|
|
void uvc_added_signal(void)
|
{
|
pthread_mutex_lock(&run_mutex);
|
pthread_cond_signal(&video_added);
|
pthread_mutex_unlock(&run_mutex);
|
}
|
|
static void uvc_added_wait(void)
|
{
|
pthread_mutex_lock(&run_mutex);
|
if (run_flag)
|
pthread_cond_wait(&video_added, &run_mutex);
|
pthread_mutex_unlock(&run_mutex);
|
}
|
|
static void *uvc_control_thread(void *arg)
|
{
|
uint32_t flag = *(uint32_t *)arg;
|
|
while (run_flag)
|
{
|
if (!check_uvc_video_id())
|
{
|
add_uvc_video();
|
/* Ensure main was waiting for this signal */
|
usleep(500);
|
uvc_added_signal();
|
if (flag & UVC_CONTROL_LOOP_ONCE)
|
break;
|
uvc_control_wait();
|
uvc_video_id_exit_all();
|
}
|
else
|
{
|
uvc_control_wait();
|
}
|
}
|
pthread_exit(NULL);
|
}
|
|
int uvc_control_loop(void)
|
{
|
if (uvc_restart)
|
{
|
//uvc_video_id_exit_all();
|
//add_uvc_video();
|
uvc_restart = false;
|
return 0;
|
}
|
if (uvc_ctrl[2].stop)
|
{
|
#ifndef USE_RK_AISERVER
|
if (camera_stop_callback)
|
camera_stop_callback();
|
#endif
|
uvc_ctrl[2].stop = false;
|
}
|
|
if (uvc_ctrl[2].start)
|
{
|
LOG_INFO("%s: video_id:%d, width:%d,height:%d,fps:%d,format:%d,eptz:%d !\n", __func__,
|
uvc_ctrl[2].id, uvc_ctrl[2].width, uvc_ctrl[2].height, uvc_ctrl[2].fps, uvc_ctrl[2].format, uvc_ctrl[2].eptz);
|
#ifndef USE_RK_AISERVER
|
if (camera_start_callback)
|
{
|
LOG_INFO("%s camera_start_callback start!\n", __func__);
|
camera_start_callback(uvc_ctrl[2].id, uvc_ctrl[2].width, uvc_ctrl[2].height, uvc_ctrl[2].fps, uvc_ctrl[2].format, uvc_ctrl[2].eptz);
|
}
|
#endif
|
//camera_control_start(uvc_ctrl[2].id, uvc_ctrl[2].width, uvc_ctrl[2].height, uvc_ctrl[2].fps);
|
uvc_ctrl[2].start = false;
|
#ifdef CAMERA_CONTROL
|
// set fps later
|
int set_fps = uvc_ctrl[2].fps;
|
if (access("/tmp/uvc_no_set_fps", 0)){
|
//sleep(1);
|
if (access("/tmp/uvc_no_reduce_fps", 0) &&
|
uvc_ctrl[2].format == V4L2_PIX_FMT_MJPEG && uvc_ctrl[2].height > 1440) {
|
if (set_fps > 24)
|
set_fps = 24; // should >= 22
|
}
|
int timeout = 0;
|
while(timeout < 4) {
|
if(check_ispserver_work()) {
|
camera_pu_control_set(UVC_PU_FPS_CONTROL, set_fps);// set camera fps
|
break;
|
}
|
timeout++;
|
if(timeout == 4){
|
LOG_INFO("check ispserver is no ready,pu set fail!\n");
|
break;
|
}
|
usleep(500000);
|
}
|
}
|
#endif
|
}
|
|
if(uvc_ctrl[2].suspend)
|
{
|
if (access("/tmp/uvc_no_suspend", 0)){
|
sleep(5);
|
if(uvc_ctrl[2].suspend){
|
if (!uvc_video_get_uvc_process(uvc_ctrl[2].id))
|
{
|
LOG_INFO("uvc ready to suspend...\n");
|
uvc_ctrl[2].suspend = 0;
|
system("touch /tmp/uvc_goto_suspend");
|
}
|
}
|
}
|
}
|
return 1;
|
}
|
|
int uvc_control_run(uint32_t flags)
|
{
|
uvc_depth_cnt = -1;
|
uvc_rgb_cnt = -1;
|
uvc_flags = flags;
|
if ((flags & UVC_CONTROL_CHECK_STRAIGHT) || (flags & UVC_CONTROL_CAMERA))
|
{
|
if (!check_uvc_video_id())
|
{
|
add_uvc_video();
|
}
|
}
|
else
|
{
|
uevent_monitor_run(flags);
|
if (pthread_create(&run_id, NULL, uvc_control_thread, &flags))
|
{
|
LOG_ERROR("%s: pthread_create failed!\n", __func__);
|
return -1;
|
}
|
uvc_added_wait();
|
}
|
|
return 0;
|
}
|
|
void uvc_control_join(uint32_t flags)
|
{
|
uvc_flags = flags;
|
if ((flags & UVC_CONTROL_CHECK_STRAIGHT) || (flags & UVC_CONTROL_CAMERA))
|
{
|
uvc_video_id_exit_all();
|
if (camera_stop_callback)
|
camera_stop_callback();
|
}
|
else
|
{
|
run_flag = false;
|
uvc_control_signal();
|
pthread_join(run_id, NULL);
|
if (flags & UVC_CONTROL_LOOP_ONCE)
|
;
|
uvc_video_id_exit_all();
|
}
|
}
|
|
void set_uvc_control_suspend(int suspend)
|
{
|
LOG_INFO("suspend is %d\n",suspend);
|
uvc_ctrl[2].suspend = suspend;
|
if ( (suspend == 0) && !access("/tmp/uvc_goto_suspend", 0))
|
system("rm /tmp/uvc_goto_suspend");
|
}
|
|
void set_uvc_control_start(int video_id, int width, int height, int fps, int format, int eptz)
|
{
|
LOG_DEBUG("%s!\n", __func__);
|
if (/*uvc_video_id_get(0) == video_id*/ 1)
|
{
|
LOG_DEBUG("%s: video_id:%d, width:%d,height:%d,fps:%d,eptz:%d!\n", __func__, video_id, width, height, fps, eptz);
|
uvc_ctrl[2].id = video_id;
|
uvc_ctrl[2].width = width;
|
uvc_ctrl[2].height = height;
|
uvc_ctrl[2].fps = fps;
|
uvc_ctrl[2].format = format;
|
uvc_ctrl[2].start = true;
|
uvc_ctrl[2].eptz = eptz;
|
}
|
else
|
LOG_ERROR("unexpect uvc!\n");
|
}
|
|
void set_uvc_control_stop(void)
|
{
|
LOG_INFO("%s!\n", __func__);
|
uvc_ctrl[2].stop = true;
|
}
|
|
void set_uvc_control_restart(void)
|
{
|
if (uvc_flags & UVC_CONTROL_CAMERA)
|
{
|
LOG_INFO("received uvc to exit,restart to recovery now!\n");
|
//system("killall -9 uvc_app &");
|
uvc_restart = true;
|
}
|
}
|
