lai/gk-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b1928b41c059832c09a15ca3c85d1b0212faa92d
gk-sdk/sample/quickstart/quickstart_comm.c
T

336 lines
10 KiB
C
Executable File
Raw Blame History

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <errno.h>
#include "xmedia_npu.h"
#include "quickstart_comm.h"
#include "media_comm.h"
#define SVP_CHECK_FRAME_COUNT 1
#define LAYER_NUM_FOUR 4
static xmedia_s32 g_svp_handle = -1;
static pthread_t g_venc_thread_pid = 0;
static quickstart_comm_venc_get_stream_param g_stream_param = {0};
static xmedia_s32 quickstart_comm_venc_save_stream(FILE* pFd, xmedia_venc_stream* pstStream)
{
xmedia_s32 i;
for (i = 0; i < pstStream->pack_count; i++) {
fwrite(pstStream->pack[i].vir_addr + pstStream->pack[i].offset,
pstStream->pack[i].len - pstStream->pack[i].offset, 1, pFd);
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 quickstart_comm_svp_proc(xmedia_void)
{
xmedia_s32 s32Ret = XMEDIA_FAILURE;
xmedia_video_frame_info video_frame = {0};
xmedia_s32 vpss_pipe = 0;
xmedia_s32 vpss_chn = 2;
xmedia_svp_task_input task_input = {0};
xmedia_svp_aov_detect_output svp_result = {0};
xmedia_s32 milli_sec = 20000;
xmedia_s32 i = 0;
for(i = 0; i < SVP_CHECK_FRAME_COUNT; i++) {
s32Ret = xmedia_vpss_acquire_ochn_frame(vpss_pipe, vpss_chn, &video_frame, milli_sec);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("Warning, acquire vpss ochn frame fail, continue, ret = 0x%x\n", s32Ret);
continue;
}
task_input.frame_num = 1;
task_input.frame = &video_frame;
s32Ret = xmedia_svp_task_process(g_svp_handle, &task_input, &svp_result);
if (s32Ret != XMEDIA_SUCCESS) {
MEDIA_ERR("xmedia_svp_process failed with %#x!\n", s32Ret);
return XMEDIA_FAILURE;
}
if (svp_result.detect_output.target_num > 0) {
MEDIA_ERR("check person success \n");
}
s32Ret = xmedia_vpss_release_ochn_frame(vpss_pipe, vpss_chn, &video_frame);
if (s32Ret != XMEDIA_SUCCESS) {
MEDIA_ERR("XMEDIA_API_VPSS_ReleaseChnFrame failed with %#x!\n", s32Ret);
}
}
return XMEDIA_SUCCESS;
}
static xmedia_void* quickstart_comm_svp_thread(xmedia_void* args)
{
xmedia_s32 s32Ret = XMEDIA_FAILURE;
xmedia_svp_modules model[1] = {0};
xmedia_svp_task_cfg task_cfg = {0};
xmedia_svp_aov_attr yolov5_attr = {0};
xmedia_s32 npu_quickstart_flag = 1;
s32Ret = xmedia_npu_set_quick_start_flag(npu_quickstart_flag);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("set npu cfg fail");
return XMEDIA_NULL;
}
s32Ret = xmedia_tde_init();
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("tde init fail");
return XMEDIA_NULL;
}
s32Ret = xmedia_svp_init();
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("svp init fail");
return XMEDIA_NULL;
}
model[0].pathname = "/usr/bin/gnn_person_detect_640x360_rgb888hwc_v0102_20240909.bin";
model[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
model[0].load_mode = XMEDIA_SVP_MODEL_FILE;
model[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
task_cfg.module_num = 1;
task_cfg.modules = model;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
s32Ret = xmedia_svp_task_create(&g_svp_handle, task_cfg);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("svp create fail.\n");
xmedia_svp_uninit();
return XMEDIA_NULL;
}
s32Ret = xmedia_svp_task_get_attr(g_svp_handle, &yolov5_attr);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("svp get task attr fail.\n");
xmedia_svp_task_destroy(g_svp_handle);
xmedia_svp_uninit();
return XMEDIA_NULL;
}
yolov5_attr.detect_threshold = 0.5f;
yolov5_attr.classifier_threshold = 0.01f;
yolov5_attr.iou_threshold = 0.45f;
yolov5_attr.max_target_num = 10;
yolov5_attr.bytetrack_enable = XMEDIA_TRUE;
yolov5_attr.motionless_filter_enable = XMEDIA_FALSE;
yolov5_attr.aov_only_target = XMEDIA_FALSE;
s32Ret = xmedia_svp_task_set_attr(g_svp_handle, &yolov5_attr);
if(s32Ret != XMEDIA_SUCCESS) {
MEDIA_ERR("svp set task attr fail.\n");
xmedia_svp_task_destroy(g_svp_handle);
xmedia_svp_uninit();
return XMEDIA_NULL;
}
quickstart_comm_svp_proc();
s32Ret = xmedia_svp_task_destroy(g_svp_handle);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("svp destory error\n");
}
g_svp_handle = -1;
xmedia_svp_uninit();
xmedia_tde_exit();
return XMEDIA_NULL;
}
static xmedia_void* quickstart_comm_venc_get_venc_stream_proc(xmedia_void* p)
{
xmedia_s32 s32Ret = XMEDIA_FAILURE;
xmedia_s32 i = 0;
xmedia_s32 venc_chn_num = 0;
xmedia_u32 venc_mask = 0;
FILE *venc_fd[VENC_MAX_CHN_NUM];
xmedia_char file_path[VENC_MAX_CHN_NUM][256] = {0};
struct timeval time_out;
xmedia_venc_chn_attr venc_chn_attr = {0};
xmedia_venc_chn_status stat = {0};
xmedia_venc_stream venc_stream = {0};
quickstart_comm_venc_get_stream_param* pst_param = NULL;
pst_param = (quickstart_comm_venc_get_stream_param*)p;
venc_chn_num = pst_param->s32Cnt;
if (venc_chn_num > VENC_MAX_CHN_NUM) {
MEDIA_ERR("input venc chn num is invail \n");
return NULL;
}
for (i = 0; i < venc_chn_num; i++) {
if (pst_param->venc_chn[i] < 0) {
MEDIA_ERR("input venc chn is invail \n");
continue;
}
s32Ret = xmedia_venc_get_chn_attr(pst_param->venc_chn[i], &venc_chn_attr);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("xmedia_venc_get_chn_attr chn[%d] failed with %#x!\n", pst_param->venc_chn[i], s32Ret);
return XMEDIA_NULL;
}
switch (venc_chn_attr.venc_attr.en_type)
{
case PT_H264:
snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".h264");
break;
case PT_H265:
snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".h265");
break;
case PT_JPEG:
snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".jpg");
break;
case PT_MJPEG:
snprintf(file_path[i], 255, "/mnt/stream_chn%d%s", i, ".mjpeg");
break;
default:
MEDIA_ERR("venc type is invail exit stream thread \n");
return NULL;
}
venc_fd[i] = fopen(file_path[i],"wb");
if (venc_fd[i] == NULL) {
MEDIA_ERR("open venc stream save file fail\n");
return NULL;
}
venc_mask |= 1 << pst_param->venc_chn[i];
}
while (g_stream_param.thread_start)
{
time_out.tv_sec = 2;
time_out.tv_usec = 0;
s32Ret = xmedia_venc_select(venc_mask, &time_out);
if (s32Ret == XMEDIA_ERRCODE_INVALID_PARAM || s32Ret == XMEDIA_FAILURE) {
MEDIA_ERR("select err\n");
break;
} else if (s32Ret == XMEDIA_ERRCODE_TIMEOUT) {
MEDIA_PRT("get venc stream time out, continue. \n");
continue;
}
for (i = 0; i < venc_chn_num; i++) {
if (pst_param->venc_chn[i] < 0) {
MEDIA_ERR("input venc chn is invail \n");
continue;
}
s32Ret = xmedia_venc_query_status(pst_param->venc_chn[i], &stat);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("xmedia_venc_query_status chn[%d] failed with %#x!\n", pst_param->venc_chn[i], s32Ret);
break;
}
if (0 == stat.cur_packs) {
continue;
}
memset(&venc_stream, 0, sizeof(venc_stream));
venc_stream.pack = (xmedia_venc_pack*)malloc(sizeof(xmedia_venc_pack) * stat.cur_packs);
if (XMEDIA_NULL == venc_stream.pack) {
MEDIA_ERR("malloc stream pack failed!\n");
break;
}
venc_stream.pack_count = stat.cur_packs;
s32Ret = xmedia_venc_get_stream(pst_param->venc_chn[i], &venc_stream, XMEDIA_TRUE);
if (XMEDIA_SUCCESS != s32Ret) {
free(venc_stream.pack);
venc_stream.pack = XMEDIA_NULL;
xmedia_venc_release_stream(pst_param->venc_chn[i], &venc_stream);
MEDIA_ERR("xmedia_venc_get_stream failed with %#x!\n", s32Ret);
break;
}
quickstart_comm_venc_save_stream(venc_fd[i], &venc_stream);
s32Ret = xmedia_venc_release_stream(pst_param->venc_chn[i], &venc_stream);
if (XMEDIA_SUCCESS != s32Ret) {
MEDIA_ERR("xmedia_venc_release_stream failed!\n");
free(venc_stream.pack);
venc_stream.pack = XMEDIA_NULL;
break;
}
free(venc_stream.pack);
venc_stream.pack = XMEDIA_NULL;
}
}
for (i = 0; i < venc_chn_num; i++) {
if (venc_fd[i] != NULL) {
fclose(venc_fd[i]);
venc_fd[i] = NULL;
}
}
return NULL;
}
xmedia_s32 quickstart_comm_venc_start_get_stream(xmedia_s32 venc_chn[], xmedia_s32 venc_chn_num)
{
xmedia_s32 i = 0;
g_stream_param.thread_start = XMEDIA_TRUE;
g_stream_param.s32Cnt = venc_chn_num;
for (i = 0; i < venc_chn_num; i++) {
g_stream_param.venc_chn[i] = venc_chn[i];
}
return pthread_create(&g_venc_thread_pid, 0, quickstart_comm_venc_get_venc_stream_proc, (xmedia_void*)&g_stream_param);
}
xmedia_s32 quickstart_comm_venc_stop_get_stream(void)
{
if (XMEDIA_TRUE == g_stream_param.thread_start) {
g_stream_param.thread_start = XMEDIA_FALSE;
if (g_venc_thread_pid > 0) {
pthread_join(g_venc_thread_pid, 0);
}
}
return XMEDIA_SUCCESS;
}
xmedia_s32 quickstart_comm_svp_thread_create(xmedia_void)
{
xmedia_s32 s32Ret = -1;
pthread_attr_t svp_create;
pthread_t svp_thread;
pthread_attr_init(&svp_create);
pthread_attr_setdetachstate(&svp_create, PTHREAD_CREATE_DETACHED);
s32Ret = pthread_create(&svp_thread, &svp_create, quickstart_comm_svp_thread, NULL);
if(s32Ret != 0)
{
MEDIA_ERR("create svp fail \n");
}
return s32Ret;
}
Reference in New Issue View Git Blame Copy Permalink