lai/gk-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
gk-sdk/sample/npu/demo_ai/sample_svp_main.c
T

3567 lines
165 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include "sample_comm.h"
#include "sample_comm_sys.h"
#include "sample_comm_vi.h"
#include "sample_comm_vpss.h"
#include "sample_comm_vo.h"
#include "sample_comm_isp.h"
#include "sample_comm_vgs.h"
#include "sample_comm_venc.h"
#include "sample_comm_ircut.h"
#include "sample_comm_livestream.h"
#include "sample_svp_main.h"
//#define SAMPLE_TIME_DEBUG 1
#define SVP_SMALL_STREAM_W 640
#define SVP_SMALL_STREAM_H 360
#define SVP_MID_STREAM_W 1280
#define SVP_MID_STREAM_H 720
#define SVP_BIG_STREAM_W 1920
#define SVP_BIG_STREAM_H 1080
#define SAMPLE_MAX_STRING_NUM 64
#define SVP_SCALE_RATIO 10000.0f
#ifdef SAMPLE_TIME_DEBUG
static struct timeval g_stTimeCostStart;
static struct timeval g_stTimeCostEnd;
#define TIME_COST_START() do { \
gettimeofday(&g_stTimeCostStart,NULL); \
} while(0)
#define TIME_COST_END() do { \
gettimeofday(&g_stTimeCostEnd,NULL); \
} while(0)
#define TIME_COST_PRINT(info) do { \
xmedia_u64 u64TimeUseMs = (g_stTimeCostEnd.tv_sec - g_stTimeCostStart.tv_sec) * 1000000 \
+ (g_stTimeCostEnd.tv_usec - g_stTimeCostStart.tv_usec); \
printf("%s cost time:%llu us\n",info,u64TimeUseMs); \
} while(0)
#endif
static sample_comm_sensor_type sample_svp_sensor_type[MAX_SENSOR_NUM] = { SENSOR0_TYPE, SENSOR1_TYPE, SENSOR2_TYPE,
SENSOR3_TYPE, SENSOR4_TYPE };
static sample_comm_screen_type sample_vo_screen_type[MAX_SCREEN_NUM] = { SCREEN0_TYPE, SCREEN0_TYPE};
static xmedia_bool g_force_exit = XMEDIA_FALSE;
static xmedia_bool g_venc_use = XMEDIA_TRUE;
xmedia_bool g_svp_start_flag = XMEDIA_FALSE;
static pthread_t g_svp_thread;
static xmedia_svp_cfg g_svp_cfg = { 0 };
#ifdef USE_OSD
static BITMAP_S g_bitmap;
rect_size sample_ivp_caculate_font_size(font_size_e font_size)
{
xmedia_s32 asc_width = 0;
xmedia_s32 asc_height = 0;
rect_size font;
switch(font_size) {
case FONT_SIZE_16:
asc_width = 8;
asc_height = 16;
break;
case FONT_SIZE_20:
asc_width = 10;
asc_height = 20;
break;
case FONT_SIZE_24:
asc_width = 12;
asc_height = 24;
break;
case FONT_SIZE_32:
asc_width = 16;
asc_height = 32;
break;
case FONT_SIZE_40:
asc_width = 20;
asc_height = 40;
break;
case FONT_SIZE_48:
asc_width = 24;
asc_height = 48;
break;
case FONT_SIZE_56:
asc_width = 28;
asc_height = 56;
break;
default:
SAMPLE_PRT("not support this font size: %d\n", font_size);
asc_width = 0;
asc_height = 0;
}
font.width = asc_width;
font.height = asc_height;
return font;
}
xmedia_s32 sample_construct_string_bitmap(xmedia_char* string_content, xmedia_s32 string_len,
font_size_e font_type, BITMAP_S* bit_map)
{
canvas_t *canvas_context = XMEDIA_NULL;
rect_size font_rect_size;
xmedia_u64 vgs_osd_phy_addr = 0;
font_rect_size = sample_ivp_caculate_font_size(font_type);
if ((font_rect_size.height == 0) || (font_rect_size.width == 0) || (string_len == 0)) {
SAMPLE_PRT("Invalid font size, error! %d-%d|%d\n", font_rect_size.height,font_rect_size.width,string_len);
return XMEDIA_FAILURE;
}
if (bit_map == XMEDIA_NULL) {
SAMPLE_PRT("bit_map can not be NULL, error \n");
return XMEDIA_FAILURE;
}
canvas_context = canvas_init(font_rect_size.width * string_len, font_rect_size.height);
if (canvas_context == XMEDIA_NULL) {
SAMPLE_PRT("No free canvas, error! \n");
return XMEDIA_FAILURE;
}
canvas_clear(canvas_context);
// string must be end with 0;
canvas_fill_text(canvas_context, 0, 0, string_content, font_type,
TEXT_STYLE_FOREGROUND_WHRITE | TEXT_STYLE_BACKGROUND_BLACK);
bit_map->u32Width = canvas_context->width;
bit_map->u32Height = canvas_context->height;
bit_map->pData = canvas_context->pixels;
bit_map->enPixelFormat = XMEDIA_VIDEO_PIXEL_FMT_ARGB_8888;
vgs_osd_phy_addr = xmedia_mmz_alloc(XMEDIA_NULL, "osd_buf", canvas_context->width * canvas_context->height * 4);
if (0 == vgs_osd_phy_addr) {
SAMPLE_PRT("xmedia_mmz_alloc %d failed with!\n", bit_map->u32Height*bit_map->u32Width*4);
canvas_deinit(canvas_context);
return XMEDIA_FAILURE;
}
xmedia_void *vgs_osd_vir_addr =
xmedia_mmz_map(vgs_osd_phy_addr, canvas_context->width * canvas_context->height * 4, XMEDIA_FALSE);
if (vgs_osd_vir_addr == 0) {
SAMPLE_PRT("xmedia_mmz_map failed\n");
canvas_deinit(canvas_context);
return XMEDIA_FAILURE;
}
memcpy(vgs_osd_vir_addr, bit_map->pData, canvas_context->width * canvas_context->height * 4);
xmedia_mmz_unmap(vgs_osd_vir_addr);
bit_map->pData = CONVERT_TO_32BIT_ADDR(vgs_osd_phy_addr);
canvas_deinit(canvas_context);
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_disconstruct_string_bitmap(BITMAP_S *bitmap_ptr)
{
xmedia_u64 vgs_osd_phy_addr = 0;
vgs_osd_phy_addr = CONVERT_TO_64BIT_ADDR(bitmap_ptr->pData);
xmedia_mmz_free(vgs_osd_phy_addr);
memset(bitmap_ptr, 0, sizeof(BITMAP_S));
return XMEDIA_SUCCESS;
}
xmedia_s32 utf8_to_gbk(xmedia_char *utf8_string, xmedia_char *gbk_string)
{
if (strlen(utf8_string) < 3) {
return XMEDIA_FAILURE;
}
if (strncmp(utf8_string, "粤", 3) == 0) {
memcpy(gbk_string, "\xD4\xC1",2);
} else if (strncmp(utf8_string, "桂", 3) == 0) {
memcpy(gbk_string, "\xB9\xF0",2);
} else if (strncmp(utf8_string, "贵", 3) == 0) {
memcpy(gbk_string, "\xB9\xF3",2);
} else if (strncmp(utf8_string, "冀", 3) == 0) {
memcpy(gbk_string, "\xBC\xBD",2);
} else if (strncmp(utf8_string, "吉", 3) == 0) {
memcpy(gbk_string, "\xBC\xAA",2);
} else if (strncmp(utf8_string, "京", 3) == 0) {
memcpy(gbk_string, "\xBE\xA9",2);
} else if (strncmp(utf8_string, "辽", 3) == 0) {
memcpy(gbk_string, "\xC7\xED",2);
} else if (strncmp(utf8_string, "陕", 3) == 0) {
memcpy(gbk_string, "\xC9\xC2",2);
} else if (strncmp(utf8_string, "苏", 3) == 0) {
memcpy(gbk_string, "\xCB\xD5",2);
} else if (strncmp(utf8_string, "湘", 3) == 0) {
memcpy(gbk_string, "\xCF\xE6",2);
} else if (strncmp(utf8_string, "渝", 3) == 0) {
memcpy(gbk_string, "\xD3\xE5",2);
} else if (strncmp(utf8_string, "豫", 3) == 0) {
memcpy(gbk_string, "\xD4\xA5",2);
} else if (strncmp(utf8_string, "藏", 3) == 0) {
memcpy(gbk_string, "\xB2\xD4",2);
} else if (strncmp(utf8_string, "川", 3) == 0) {
memcpy(gbk_string, "\xB4\xA8",2);
} else if (strncmp(utf8_string, "鄂", 3) == 0) {
memcpy(gbk_string, "\xB6\xF5",2);
} else if (strncmp(utf8_string, "甘", 3) == 0) {
memcpy(gbk_string, "\xB8\xCA",2);
} else if (strncmp(utf8_string, "赣", 3) == 0) {
memcpy(gbk_string, "\xB8\xD3",2);
} else if (strncmp(utf8_string, "黑", 3) == 0) {
memcpy(gbk_string, "\xBA\xDA",2);
} else if (strncmp(utf8_string, "沪", 3) == 0) {
memcpy(gbk_string, "\xBB\xA6",2);
} else if (strncmp(utf8_string, "津", 3) == 0) {
memcpy(gbk_string, "\xBD\xF2",2);
} else if (strncmp(utf8_string, "晋", 3) == 0) {
memcpy(gbk_string, "\xBD\xFA",2);
} else if (strncmp(utf8_string, "鲁", 3) == 0) {
memcpy(gbk_string, "\xC2\xB3",2);
} else if (strncmp(utf8_string, "蒙", 3) == 0) {
memcpy(gbk_string, "\xC3\xC9",2);
} else if (strncmp(utf8_string, "闽", 3) == 0) {
memcpy(gbk_string, "\xC3\xF6",2);
} else if (strncmp(utf8_string, "宁", 3) == 0) {
memcpy(gbk_string, "\xC4\xFE",2);
} else if (strncmp(utf8_string, "青", 3) == 0) {
memcpy(gbk_string, "\xC7\xE0",2);
} else if (strncmp(utf8_string, "挂", 3) == 0) {
memcpy(gbk_string, "\xB9\xD2",2);
} else if (strncmp(utf8_string, "皖", 3) == 0) {
memcpy(gbk_string, "\xCD\xEE",2);
} else if (strncmp(utf8_string, "新", 3) == 0) {
memcpy(gbk_string, "\xD0\xC2",2);
} else if (strncmp(utf8_string, "云", 3) == 0) {
memcpy(gbk_string, "\xD4\xC6",2);
} else if (strncmp(utf8_string, "浙", 3) == 0) {
memcpy(gbk_string, "\xD5\xE3",2);
} else if (strncmp(utf8_string, "琼", 3) == 0) {
memcpy(gbk_string, "\xC7\xF8",2);
} else if (strncmp(utf8_string, "学", 3) == 0) {
memcpy(gbk_string, "\xD1\xA7",2);
} else if (strncmp(utf8_string, "警", 3) == 0) {
memcpy(gbk_string, "\xBE\xAF",2);
} else if (strncmp(utf8_string, "领", 3) == 0) {
memcpy(gbk_string, "\xC1\xEC",2);
} else if (strncmp(utf8_string, "使", 3) == 0) {
memcpy(gbk_string, "\xCA\xB9",2);
} else if (strncmp(utf8_string, "港", 3) == 0) {
memcpy(gbk_string, "\xB8\xD8",2);
} else if (strncmp(utf8_string, "澳", 3) == 0) {
memcpy(gbk_string, "\xB0\xC4",2);
} else {
memcpy(gbk_string, "\xCE\xDE",2); // 无
}
return XMEDIA_SUCCESS;
}
// 打印跟踪信息
xmedia_s32 sample_target_osd(xmedia_video_frame_info *frame_info, xmedia_s32 s32x, xmedia_s32 s32y,
xmedia_char *format_untile_line)
{
xmedia_s32 ret;
font_size_e font_size = FONT_SIZE_16;
VGS_HANDLE handle = -1;
xmedia_char str_array[512];
rect_size font_rect_size;
xmedia_vgs_osd_attr osd_attr = {0};
xmedia_vgs_frame_info task_info = {0};
memcpy(&task_info.img_in, frame_info, sizeof(xmedia_video_frame_info));
memcpy(&task_info.img_out, frame_info, sizeof(xmedia_video_frame_info));
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_ivp_osd_info_t xmedia_vgs_create_job failed %#x!\n", ret);
handle = -1;
return XMEDIA_FAILURE;
}
font_rect_size = sample_ivp_caculate_font_size(font_size);
if((font_rect_size.height == 0)||(font_rect_size.width == 0)) {
xmedia_vgs_cancel_job(handle);
return XMEDIA_FAILURE;
}
memset(str_array, 0, sizeof(str_array));
memcpy(str_array, format_untile_line, sizeof(str_array));
ret = sample_construct_string_bitmap(str_array, strlen(str_array), font_size, &g_bitmap);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("string_bitmap failed \n");
xmedia_vgs_cancel_job(handle);
handle = -1;
return XMEDIA_FAILURE;
}
osd_attr.osd_rect.y = ((s32y + g_bitmap.u32Height) > SVP_SMALL_STREAM_H ? s32y - g_bitmap.u32Height : s32y);
osd_attr.osd_rect.y = (osd_attr.osd_rect.y + 1) / 2 * 2;
osd_attr.osd_rect.x = ((s32x + g_bitmap.u32Width) > SVP_SMALL_STREAM_W ? s32x - g_bitmap.u32Width : s32x);
osd_attr.osd_rect.x = (osd_attr.osd_rect.x + 1) / 2 * 2;
osd_attr.osd_rect.width = g_bitmap.u32Width;
osd_attr.osd_rect.height = g_bitmap.u32Height;
// printf("x[%d]y[%d]w[%d]h[%d]\n", osd_attr.osd_rect.x,
// osd_attr.osd_rect.y,osd_attr.osd_rect.width,osd_attr.osd_rect.height);
osd_attr.pixel_fmt = g_bitmap.enPixelFormat;
osd_attr.alpha0 = 0;
osd_attr.alpha1 = 0xff;
osd_attr.is_osd_revert = XMEDIA_FALSE;
osd_attr.stride = g_bitmap.u32Width*4;
osd_attr.phys_addr = CONVERT_TO_64BIT_ADDR(g_bitmap.pData);
ret = xmedia_vgs_add_task_osd(handle, &task_info, &osd_attr, 1);
if(ret != XMEDIA_SUCCESS) {
xmedia_vgs_cancel_job(handle);
sample_disconstruct_string_bitmap(&g_bitmap);
SAMPLE_PRT("xmedia_vgs_wait_job failed!\n");
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_submit_job(handle);
if(ret != XMEDIA_SUCCESS) {
xmedia_vgs_cancel_job(handle);
sample_disconstruct_string_bitmap(&g_bitmap);
SAMPLE_PRT("xmedia_vgs_submit_job failed!\n");
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000);
if(ret != XMEDIA_SUCCESS) {
xmedia_vgs_cancel_job(handle);
sample_disconstruct_string_bitmap(&g_bitmap);
SAMPLE_PRT("xmedia_vgs_wait_job failed!\n");
return XMEDIA_FAILURE;
}
sample_disconstruct_string_bitmap(&g_bitmap);
return XMEDIA_SUCCESS;
}
#endif
xmedia_s32 sample_vgs_resize(const xmedia_video_frame_info *input_frame, xmedia_video_frame_info *output_frame)
{
xmedia_s32 ret;
xmedia_s32 vgs_handle;
xmedia_vgs_frame_info vgs_task;
memset(&vgs_task, 0, sizeof(vgs_task));
ret = xmedia_vgs_create_job(&vgs_handle);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("XMEDIA_API_VGS_BeginJob failed %#x!\n", ret);
return XMEDIA_FAILURE;
}
output_frame->mod_id = MOD_ID_USER;
output_frame->frame.compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
output_frame->frame.video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
output_frame->frame.bit_width = XMEDIA_VIDEO_DATA_WIDTH_8;
memcpy(&vgs_task.img_in, input_frame, sizeof(xmedia_video_frame_info));
memcpy(&vgs_task.img_out, output_frame, sizeof(xmedia_video_frame_info));
ret = xmedia_vgs_add_task_scale(vgs_handle, &vgs_task, XMEDIA_VIDEO_SCALE_MODE_NORMAL);
if (XMEDIA_SUCCESS != ret) {
(xmedia_void) xmedia_vgs_cancel_job(vgs_handle);
SAMPLE_PRT("XMEDIA_API_VGS_AddScaleTask failed %#x!\n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_submit_job(vgs_handle);
if (XMEDIA_SUCCESS != ret) {
(xmedia_void) xmedia_vgs_cancel_job(vgs_handle);
SAMPLE_PRT("vgs submit failed %#x!\n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(vgs_handle, 2000); // 2000ms超时时间
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vgs wait job failed %#x!\n", ret);
return ret;
}
return XMEDIA_SUCCESS;
}
// dms画图
static xmedia_s32 sample_svp_draw_dms(xmedia_svp_dms_output *dms_result,xmedia_video_frame_info *frame)
{
xmedia_s32 ret;
xmedia_vgs_frame_info task = {0};
xmedia_vgs_cover_attr cover[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_s32 handle = -1;
xmedia_s32 i,j;
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_u8 object_num = 0;
xmedia_u8 tmp_num = dms_result->target_num;
if (0 == tmp_num) {
return XMEDIA_FAILURE;
} else if (tmp_num > XMEDIA_SVP_MAX_TARGET_NUM) {
return XMEDIA_FAILURE;
}
for (i = 0; i < tmp_num; i++) {
x1 = (xmedia_s32)roundf(dms_result->targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(dms_result->targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(dms_result->targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(dms_result->targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[object_num].x = x1;
target_rect[object_num].y = y1;
target_rect[object_num].width = w;
target_rect[object_num].height = h;
object_num++;
for (j = 0; j < dms_result->targets[i].dms_report.phone_num; j++) {
x1 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.phone[j].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.phone[j].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.phone[j].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.phone[j].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[object_num].x = x1;
target_rect[object_num].y = y1;
target_rect[object_num].width = w;
target_rect[object_num].height = h;
object_num++;
}
for (j = 0; j < dms_result->targets[i].dms_report.cigar_num; j++) {
x1 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.cigar[j].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.cigar[j].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.cigar[j].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(dms_result->targets[i].dms_report.cigar[j].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[object_num].x = x1;
target_rect[object_num].y = y1;
target_rect[object_num].width = w;
target_rect[object_num].height = h;
object_num++;
}
}
object_num = object_num > XMEDIA_SVP_MAX_TARGET_NUM ? XMEDIA_SVP_MAX_TARGET_NUM : object_num;
memcpy(&task.img_in,frame,sizeof(xmedia_video_frame_info));
memcpy(&task.img_out,frame,sizeof(xmedia_video_frame_info));
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret)
{
SAMPLE_PRT("xmedia_vgs_create_job failed !\n");
handle = -1;
return XMEDIA_FAILURE;
}
for (i = 0; i < object_num; i++) {
if (dms_result->targets[i].special_target == XMEDIA_TRUE) {
cover[i].color = 0x0000FF; // blue
} else {
cover[i].color = 0xFF0000; // red
}
cover[i].cover_type = XMEDIA_VGS_COVER_TYPE_QUAD_RANGLE;
cover[i].quadrangle.is_solid = XMEDIA_FALSE;
cover[i].quadrangle.thick = 2;
cover[i].quadrangle.points[0].x = target_rect[i].x;
cover[i].quadrangle.points[0].y = target_rect[i].y;
cover[i].quadrangle.points[1].x = target_rect[i].x + target_rect[i].width;
cover[i].quadrangle.points[1].y = target_rect[i].y;
cover[i].quadrangle.points[2].x = target_rect[i].x + target_rect[i].width;
cover[i].quadrangle.points[2].y = target_rect[i].y + target_rect[i].height;
cover[i].quadrangle.points[3].x = target_rect[i].x;
cover[i].quadrangle.points[3].y = target_rect[i].y + target_rect[i].height;
}
ret = xmedia_vgs_add_task_cover(handle,&task,&cover[0], object_num);
if (XMEDIA_SUCCESS != ret)
{
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_add_task_cover failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_submit_job(handle);
if (XMEDIA_SUCCESS != ret)
{
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_submit_job failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000); // 2000ms超时时间
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_wait_job failed ! ret [%d] \n", ret);
return ret;
}
return XMEDIA_SUCCESS;
}
// yolov8画图
static xmedia_s32 sample_svp_draw_v8(xmedia_video_rect target_rect[], xmedia_video_frame_info *frame,
xmedia_svp_yolov8_output result)
{
xmedia_s32 ret;
xmedia_vgs_frame_info task = { 0 };
xmedia_vgs_cover_attr cover[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_s32 handle = -1;
xmedia_s32 i;
xmedia_u8 object_num = result.target_num;
if (0 == object_num) {
return XMEDIA_FAILURE;
}
// object_num = 1;
object_num = object_num > XMEDIA_SVP_MAX_TARGET_NUM ? XMEDIA_SVP_MAX_TARGET_NUM : object_num;
memcpy(&task.img_in, frame, sizeof(xmedia_video_frame_info));
memcpy(&task.img_out, frame, sizeof(xmedia_video_frame_info));
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("xmedia_vgs_create_job failed !\n");
handle = -1;
return XMEDIA_FAILURE;
}
for (i = 0; i < object_num; i++) {
if (result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_FIRE ||
result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_SMOKE) {
cover[i].color = 0x00FF00; // green
} else {
cover[i].color = 0xFF0000; // red
}
cover[i].cover_type = XMEDIA_VGS_COVER_TYPE_QUAD_RANGLE;
cover[i].quadrangle.is_solid = XMEDIA_FALSE;
cover[i].quadrangle.thick = 2;
cover[i].quadrangle.points[0].x = target_rect[i].x;
cover[i].quadrangle.points[0].y = target_rect[i].y;
cover[i].quadrangle.points[1].x = target_rect[i].x + target_rect[i].width;
cover[i].quadrangle.points[1].y = target_rect[i].y;
cover[i].quadrangle.points[2].x = target_rect[i].x + target_rect[i].width;
cover[i].quadrangle.points[2].y = target_rect[i].y + target_rect[i].height;
cover[i].quadrangle.points[3].x = target_rect[i].x;
cover[i].quadrangle.points[3].y = target_rect[i].y + target_rect[i].height;
}
ret = xmedia_vgs_add_task_cover(handle, &task, &cover[0], object_num);
if (XMEDIA_SUCCESS != ret) {
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_add_task_cover failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_submit_job(handle);
if (XMEDIA_SUCCESS != ret) {
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_submit_job failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000); // 2000ms超时时间
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_wait_job failed ! ret [%d] \n", ret);
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_svp_draw(xmedia_video_rect target_rect[],
xmedia_video_frame_info *frame,
xmedia_svp_yolov5_output result)
{
xmedia_s32 ret;
xmedia_vgs_frame_info task = {0};
xmedia_vgs_cover_attr cover[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_s32 handle = -1;
xmedia_s32 i;
xmedia_u8 object_num = result.target_num;
if (0 == object_num)
{
return XMEDIA_FAILURE;
}
//object_num = 1;
object_num = object_num > XMEDIA_SVP_MAX_TARGET_NUM ? XMEDIA_SVP_MAX_TARGET_NUM : object_num;
memcpy(&task.img_in,frame,sizeof(xmedia_video_frame_info));
memcpy(&task.img_out,frame,sizeof(xmedia_video_frame_info));
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret)
{
SAMPLE_PRT("xmedia_vgs_create_job failed !\n");
handle = -1;
return XMEDIA_FAILURE;
}
for (i = 0; i < object_num; i++) {
if (result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_FIREWORKS_SMOKE ||
result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_TRICYCLER) {
cover[i].color = 0x0000FF; // blue
} else if (result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_BIKER) {
cover[i].color = 0x000FFF;
} else if (result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_MOTOR) {
cover[i].color = 0x0F000F;
} else if (result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_MOTORER) {
cover[i].color = 0xFF00FF;
} else if (result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_TRICYCLE) {
cover[i].color = 0x00FF00;
} else {
cover[i].color = 0xFF0000; // red
}
cover[i].cover_type = XMEDIA_VGS_COVER_TYPE_QUAD_RANGLE;
cover[i].quadrangle.is_solid = XMEDIA_FALSE;
cover[i].quadrangle.thick = 2;
cover[i].quadrangle.points[0].x = target_rect[i].x;
cover[i].quadrangle.points[0].y = target_rect[i].y;
cover[i].quadrangle.points[1].x = target_rect[i].x + target_rect[i].width;
cover[i].quadrangle.points[1].y = target_rect[i].y;
cover[i].quadrangle.points[2].x = target_rect[i].x + target_rect[i].width;
cover[i].quadrangle.points[2].y = target_rect[i].y + target_rect[i].height;
cover[i].quadrangle.points[3].x = target_rect[i].x;
cover[i].quadrangle.points[3].y = target_rect[i].y + target_rect[i].height;
}
ret = xmedia_vgs_add_task_cover(handle, &task, &cover[0], object_num);
if (XMEDIA_SUCCESS != ret) {
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_add_task_cover failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_submit_job(handle);
if (XMEDIA_SUCCESS != ret) {
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_submit_job failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_wait_job failed ! ret [%d] \n", ret);
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_svp_draw_keypoint(xmedia_svp_keypoint target_rect[], xmedia_u32 kpt_num,
xmedia_video_frame_info* frame)
{
xmedia_s32 ret;
xmedia_vgs_frame_info task = { 0 };
xmedia_vgs_cover_attr cover[MAX_DETECT_KEYPOINT_NUM];
xmedia_s32 handle = -1;
xmedia_s32 i;
xmedia_s32 x, y;
xmedia_u8 point_num = 0;
xmedia_bool horizontal_line = XMEDIA_FALSE, vertical_line = XMEDIA_FALSE;
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("xmedia_vgs_create_job failed !\n");
handle = -1;
return XMEDIA_FAILURE;
}
for (i = 0; i < kpt_num; i++) {
x = (xmedia_s32)roundf(target_rect[i].x / 2) * 2;
y = (xmedia_s32)roundf(target_rect[i].y / 2) * 2;
x = (x < 0) ? 0 : ((x > 638) ? 638 : x);
y = (y < 0) ? 0 : ((y > 358) ? 358 : y);
cover[point_num].color = 0x0000CD;
cover[point_num].cover_type = XMEDIA_VGS_COVER_TYPE_QUAD_RANGLE;
cover[point_num].quadrangle.is_solid = XMEDIA_FALSE;
cover[point_num].quadrangle.thick = 2;
// 画2x2的小矩形标记关键点
cover[point_num].quadrangle.points[0].x = x;
cover[point_num].quadrangle.points[0].y = y;
cover[point_num].quadrangle.points[1].x = (x + 2 > 640) ? 640 : x + 2; // 不超过640
cover[point_num].quadrangle.points[1].y = y;
cover[point_num].quadrangle.points[2].x = (x + 2 > 640) ? 640 : x + 2; // 不超过640
cover[point_num].quadrangle.points[2].y = (y + 2 > 360) ? 360 : y + 2; // 不超过360
cover[point_num].quadrangle.points[3].x = x;
cover[point_num].quadrangle.points[3].y = (y + 2 > 360) ? 360 : y + 2; // 不超过360
// 检查是否构成水平线或垂直线
horizontal_line = (cover[point_num].quadrangle.points[0].y == cover[point_num].quadrangle.points[1].y &&
cover[point_num].quadrangle.points[1].y == cover[point_num].quadrangle.points[2].y &&
cover[point_num].quadrangle.points[2].y == cover[point_num].quadrangle.points[3].y);
vertical_line = (cover[point_num].quadrangle.points[0].x == cover[point_num].quadrangle.points[1].x &&
cover[point_num].quadrangle.points[1].x == cover[point_num].quadrangle.points[2].x &&
cover[point_num].quadrangle.points[2].x == cover[point_num].quadrangle.points[3].x);
if (horizontal_line || vertical_line) {
continue;
}
point_num++;
}
memcpy(&task.img_in, frame, sizeof(xmedia_video_frame_info));
memcpy(&task.img_out, frame, sizeof(xmedia_video_frame_info));
ret = xmedia_vgs_add_task_cover(handle, &task, &cover[0], point_num);
if (XMEDIA_SUCCESS != ret) {
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_add_task_cover failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_submit_job(handle);
if (XMEDIA_SUCCESS != ret) {
xmedia_vgs_cancel_job(handle);
SAMPLE_PRT("xmedia_vgs_submit_job failed ! ret [%d] \n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_wait_job failed ! ret [%d] \n", ret);
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_draw_line(xmedia_svp_keypoint* target_rect, xmedia_video_frame_info *frame)
{
xmedia_s32 ret;
xmedia_vgs_frame_info task_attr;
xmedia_u32 line_num = 17;
xmedia_u32 vgs_line_num = 0;
xmedia_u32 line_num_process = 0;
xmedia_vgs_line_attr vgs_line[17];
xmedia_s32 handle = -1;
xmedia_s32 i = 0;
xmedia_u32 index1,index2;
xmedia_u32 line_start[17][2];
xmedia_u32 line_end[17][2];
xmedia_s32 match_line[17][2] = {{0,1},{0,2},{1,3},{2,4},{3,5},{4,6},
{6,5},{5,7},{7,9},{6,8},{8,10},{6,12},
{12,14},{14,16},{5,11},{11,13},{13,15}};
memcpy(&task_attr.img_in,frame,sizeof(xmedia_video_frame_info));
memcpy(&task_attr.img_out,frame,sizeof(xmedia_video_frame_info));
for(i = 0;i < line_num; i++) {
index1 = match_line[i][0];
index2 = match_line[i][1];
if (target_rect[index1].score >= 0.2 && target_rect[index2].score >= 0.2) {
line_start[line_num_process][0] = (round(target_rect[index1].x) / 2);
line_start[line_num_process][0] = line_start[line_num_process][0] * 2;
line_start[line_num_process][1] = (round(target_rect[index1].y) / 2);
line_start[line_num_process][1] = line_start[line_num_process][1] * 2;
line_end[line_num_process][0] = (round(target_rect[index2].x) / 2);
line_end[line_num_process][0] = line_end[line_num_process][0] * 2;
line_end[line_num_process][1] = (round(target_rect[index2].y) / 2);
line_end[line_num_process][1] = line_end[line_num_process][1] * 2;
line_num_process++;
}
}
if (line_num_process == 0) {
SAMPLE_PRT("line_num_process is nullptr don't draw\n");
return XMEDIA_SUCCESS;
}
for(i = 0;i < line_num_process; i++) {
if (line_start[i][0] == line_end[i][0] && line_start[i][1] == line_end[i][1])
continue;
vgs_line[vgs_line_num].start_point.x = line_start[i][0];
vgs_line[vgs_line_num].start_point.y = line_start[i][1];
vgs_line[vgs_line_num].end_point.x = line_end[i][0];
vgs_line[vgs_line_num].end_point.y = line_end[i][1];
vgs_line[vgs_line_num].thick = 2;
vgs_line[vgs_line_num].color = 0xFF0000;
vgs_line_num ++;
}
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret)
{
SAMPLE_PRT("xmedia_vgs_craete_job failed !\n");
handle = -1;
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_add_task_line(handle, &task_attr, &vgs_line[0], vgs_line_num);
if (XMEDIA_SUCCESS != ret)
{
SAMPLE_PRT("xmedia_vgs_add_task_line failed ! ret : %x\n", ret);
}
ret = xmedia_vgs_submit_job(handle);
if (XMEDIA_SUCCESS != ret)
{
SAMPLE_PRT("xmedia_vgs_submit_job failed !\n");
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_wait_job failed ! ret [%d] \n", ret);
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_svp_draw_thick_pixel(xmedia_void* img_addr, xmedia_s32 width, xmedia_s32 height,
xmedia_s32 x, xmedia_s32 y, xmedia_s32 thickness)
{
xmedia_u8 *addr = (xmedia_u8 *)img_addr;
for(xmedia_s32 dy = -thickness/2; dy <= thickness/2; dy++) {
for(xmedia_s32 dx = -thickness/2; dx <= thickness/2; dx++) {
xmedia_s32 nx = x + dx;
xmedia_s32 ny = y + dy;
if(nx >=0 && nx < width && ny >=0 && ny < height) {
/*三组数字构成颜色为yuv的紫色*/
addr[ny * SVP_BIG_STREAM_W + nx] = 150;
addr[SVP_BIG_STREAM_W * SVP_BIG_STREAM_H + (ny / 2) * SVP_BIG_STREAM_W + nx / 2 * 2] = 44;
addr[SVP_BIG_STREAM_W * SVP_BIG_STREAM_H + (ny / 2) * SVP_BIG_STREAM_W + nx / 2 * 2 + 1] = 21;
}
}
}
}
#ifdef READ_YUV
// 文件名比较函数（升序）
static xmedia_s32 compare_names(const void *a, const void *b) {
return strcmp(*(const char **)a, *(const char **)b);
}
xmedia_s32 sample_get_input_yuv_data(xmedia_void *p, xmedia_s32 width, xmedia_s32 height, const xmedia_char *filename)
{
FILE* fp = fopen(filename, "r");
if (fp == NULL) {
SAMPLE_PRT("open input data file failed:%s \n", filename);
return XMEDIA_FAILURE;
}
xmedia_s32 filesSize = height * width * 3 / 2;
xmedia_s32 count = fread(p, sizeof(uint8_t), filesSize, fp);
fclose(fp);
if (count != filesSize) {
SAMPLE_PRT("read %s error, want to read %d , in fact read %d\n", filename, filesSize, count);
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
#endif
xmedia_s32 append_to_file(const xmedia_char* filename, const xmedia_char* content) {
FILE* file = fopen(filename, "a"); // 追加模式
if (file == XMEDIA_NULL) {
SAMPLE_PRT("can not open file: %s\n", filename);
return XMEDIA_FAILURE;
}
fputs(content, file);
fputs("\n", file);
fclose(file);
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_draw_zone(xmedia_svp_zone* zone, xmedia_video_frame_info *frame)
{
xmedia_s32 ret;
xmedia_vgs_frame_info task_attr;
xmedia_s32 handle = -1;
xmedia_s32 i = 0, j = 0, line_idx = 0;
xmedia_vgs_line_attr *vgs_line;
xmedia_u32 line_num = 0;
memcpy(&task_attr.img_in,frame,sizeof(xmedia_video_frame_info));
memcpy(&task_attr.img_out,frame,sizeof(xmedia_video_frame_info));
for (i = 0; i < zone->zone_num; i++) {
if (zone->zones[i].points_count >= 3) { // 小于3个点 无法构成封闭图形
line_num += zone->zones[i].points_count;
}
}
vgs_line = (xmedia_vgs_line_attr *)calloc(1, line_num * sizeof(xmedia_vgs_line_attr));
if (vgs_line == XMEDIA_NULL) {
SAMPLE_PRT("vgs_line calloc failed !\n");
return XMEDIA_FAILURE;
}
for (i = 0; i < zone->zone_num; i++) {
for (j = 0; j < zone->zones[i].points_count; j++) {
if (zone->zones[i].points_count < 3) { // 小于3个点 无法构成封闭图形
continue;
}
if (j == zone->zones[i].points_count - 1) {
vgs_line[line_idx].start_point.x =
(xmedia_s32)(zone->zones[i].points_array[j].x * SVP_SMALL_STREAM_W / SVP_SCALE_RATIO) / 2 * 2;
vgs_line[line_idx].start_point.y =
(xmedia_s32)(zone->zones[i].points_array[j].y * SVP_SMALL_STREAM_H / SVP_SCALE_RATIO) / 2 * 2;
vgs_line[line_idx].end_point.x =
(xmedia_s32)(zone->zones[i].points_array[0].x * SVP_SMALL_STREAM_W / SVP_SCALE_RATIO) / 2 * 2;
vgs_line[line_idx].end_point.y =
(xmedia_s32)(zone->zones[i].points_array[0].y * SVP_SMALL_STREAM_H / SVP_SCALE_RATIO) / 2 * 2;
} else {
vgs_line[line_idx].start_point.x =
(xmedia_s32)(zone->zones[i].points_array[j].x * SVP_SMALL_STREAM_W / SVP_SCALE_RATIO) / 2 * 2;
vgs_line[line_idx].start_point.y =
(xmedia_s32)(zone->zones[i].points_array[j].y * SVP_SMALL_STREAM_H / SVP_SCALE_RATIO) / 2 * 2;
vgs_line[line_idx].end_point.x =
(xmedia_s32)(zone->zones[i].points_array[j + 1].x * SVP_SMALL_STREAM_W / SVP_SCALE_RATIO) / 2 * 2;
vgs_line[line_idx].end_point.y =
(xmedia_s32)(zone->zones[i].points_array[j + 1].y * SVP_SMALL_STREAM_H / SVP_SCALE_RATIO) / 2 * 2;
}
vgs_line[line_idx].color = 0x00FF00;
vgs_line[line_idx].thick = 2;
line_idx++;
}
}
if (line_idx == 0) {
SAMPLE_PRT("line_idx is zero don't draw\n");
free(vgs_line);
return XMEDIA_SUCCESS;
}
ret = xmedia_vgs_create_job(&handle);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("xmedia_vgs_craete_job failed !\n");
handle = -1;
free(vgs_line);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_add_task_line(handle, &task_attr, vgs_line, line_idx);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("xmedia_vgs_add_task_line failed ! ret : %x\n", ret);
}
ret = xmedia_vgs_submit_job(handle);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("xmedia_vgs_submit_job failed !\n");
free(vgs_line);
return XMEDIA_FAILURE;
}
ret = xmedia_vgs_wait_job(handle, 2000);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_wait_job failed ! ret [%d] \n", ret);
free(vgs_line);
return ret;
}
free(vgs_line);
return XMEDIA_SUCCESS;
}
xmedia_void* sample_svp_proc(xmedia_void* p)
{
xmedia_s32 ret;
sample_svp_info *svp_info = (sample_svp_info *)p;
xmedia_video_frame_info video_frame;
xmedia_video_frame_info video_frame_big;
xmedia_s32 milli_sec = 20000;
xmedia_svp_task_input task_input;
xmedia_video_frame_info frame_info[2];
#ifdef READ_YUV
xmedia_s32 SVP_YUV_W = SVP_SMALL_STREAM_W;
xmedia_s32 SVP_YUV_H = SVP_SMALL_STREAM_H;
// 720P分辨率输入
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_RCNN_720P ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_CAR_RCNN_720P ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PET_RCNN_720P) {
SVP_YUV_W = SVP_MID_STREAM_W;
SVP_YUV_H = SVP_MID_STREAM_H;
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_ADAS ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_GESTURE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_EMOTION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO) {
SVP_YUV_W = SVP_BIG_STREAM_W;
SVP_YUV_H = SVP_BIG_STREAM_H;
}
DIR *dir;
struct dirent *entry;
xmedia_char *file_names[MAX_FILES_NUM];
xmedia_s32 file_count = 0;
xmedia_bool input_file_flag = XMEDIA_FALSE;
// 打开目录并读取文件名
xmedia_char *input_path = "./yuv_dir";
dir = opendir(input_path);
if (dir == NULL) {
SAMPLE_PRT("opendir %s failed\n", input_path);
return NULL;
}
while ((entry = readdir(dir)) != NULL && file_count < MAX_FILES_NUM) {
if (entry->d_type == DT_REG || entry->d_type == DT_UNKNOWN) { // 只处理普通文件
xmedia_char *ext = strrchr(entry->d_name, '.');
if (ext && (strcmp(ext, ".yuv") == 0 || strcmp(ext, ".YUV") == 0)) {
file_names[file_count] = malloc(strlen(entry->d_name) + 1);
strcpy(file_names[file_count], entry->d_name);
file_count++;
}
}
}
closedir(dir);
// 按文件名排序
qsort(file_names, file_count, sizeof(char *), compare_names);
xmedia_s32 file_index = 0;
input_file_flag = XMEDIA_TRUE;
#endif
#ifdef DMS_OPENCV
sample_dms_state dms_state = { 0 };
dms_state.distract = XMEDIA_FALSE;
dms_state.tracker_id = -1;
dms_state.warn_frame = 10;
#endif
while (g_svp_start_flag == XMEDIA_TRUE) {
ret = xmedia_vpss_acquire_ochn_frame(svp_info->vpss_pipe, svp_info->vpss_ochn[1], &video_frame, milli_sec);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT(" get vpss small frame failed !\n");
continue;
}
task_input.frame_num = 1;
if (svp_info->big_stream == XMEDIA_TRUE) {
task_input.frame_num = 2;
ret = xmedia_vpss_acquire_ochn_frame(svp_info->vpss_pipe, svp_info->vpss_ochn[2], &video_frame_big, milli_sec);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT(" get vpss big frame failed !\n");
continue;
}
}
#ifdef READ_YUV
if (input_file_flag) {
xmedia_char full_path[MAX_STR_NAME_LEN];
snprintf(full_path, sizeof(full_path), "%s/%s", input_path, file_names[file_index]);
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_ADAS ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_GESTURE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_EMOTION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO) {
xmedia_void* yuv_data = (xmedia_void*)xmedia_mmz_map(video_frame_big.frame.addr.y_phy_addr,
SVP_YUV_W * SVP_YUV_H * 3 / 2, XMEDIA_FALSE);
sample_get_input_yuv_data(yuv_data, SVP_YUV_W, SVP_YUV_H, full_path);
if (svp_info->detect_type != SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION &&
svp_info->detect_type != SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION &&
svp_info->detect_type != SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO) {
ret = sample_vgs_resize(&video_frame_big, &video_frame);
}
xmedia_mmz_unmap(yuv_data);
} else {
xmedia_void* yuv_data = (xmedia_void*)xmedia_mmz_map(video_frame.frame.addr.y_head_phy_addr,
SVP_YUV_W * SVP_YUV_H * 3 / 2, XMEDIA_FALSE);
sample_get_input_yuv_data(yuv_data, SVP_YUV_W, SVP_YUV_H, full_path);
xmedia_mmz_unmap(yuv_data);
}
SAMPLE_PRT("Processing file: %s\n", file_names[file_index]);
free(file_names[file_index]);
file_index++;
}
#endif
frame_info[0] = video_frame;
if (svp_info->big_stream == XMEDIA_TRUE) {
frame_info[1] = video_frame_big;
}
task_input.frame = frame_info;
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_AOV_PERSON) {
xmedia_svp_aov_detect_output aov_result = {0};
#ifdef SAMPLE_TIME_DEBUG
TIME_COST_START();
#endif
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &aov_result);
#ifdef SAMPLE_TIME_DEBUG
TIME_COST_END();
TIME_COST_PRINT("svp process all");
#endif
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
SAMPLE_PRT(" is target [%d] \n", aov_result.is_exist);
if (aov_result.detect_output.target_num > 0) {
xmedia_u32 w,h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
for (xmedia_s32 i = 0; i < aov_result.detect_output.target_num; i++) {
x1 = (xmedia_s32)roundf(aov_result.detect_output.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(aov_result.detect_output.targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(aov_result.detect_output.targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(aov_result.detect_output.targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
}
sample_svp_draw(&target_rect[0], &video_frame, aov_result.detect_output);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_KEYPOINT) {
xmedia_svp_yolov8_output yolov8_result = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &yolov8_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
for (xmedia_s32 i = 0; i < yolov8_result.target_num; i++) {
sample_draw_line(&yolov8_result.targets[i].kpt[0], &video_frame);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_ADAS) {
xmedia_svp_adas_result adas_result = { 0 };
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &adas_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_s32 x, y;
xmedia_float y_min, y_max;
xmedia_s32 step = 600;
xmedia_float h_s;
xmedia_float tmp_x, tmp_y;
xmedia_void* p_yuv_data = (xmedia_void*)xmedia_mmz_map(video_frame_big.frame.addr.y_phy_addr,
SVP_BIG_STREAM_W * SVP_BIG_STREAM_H * 3 / 2, XMEDIA_FALSE);
for (xmedia_s32 i = 0; i < XMEDIA_SVP_LANE_MAX_NUM; i++) {
if (adas_result.lane_fitted_point_num[i] > 0) {
switch (i) {
case 0:
y_min = adas_result.col_fitted_result[0][0].y;
y_max = adas_result.col_fitted_result[0][adas_result.lane_fitted_point_num[i] - 1].y;
for (int k = 0; k < adas_result.lane_fitted_point_num[i]; k++) {
y_min = fmin(y_min, adas_result.col_fitted_result[0][k].y);
y_max = fmax(y_max, adas_result.col_fitted_result[0][k].y);
}
h_s = y_max - y_min;
for (xmedia_s32 k = 0; k < step; k++) {
tmp_y = ((xmedia_float)k / step * h_s + y_min);
tmp_x = (xmedia_float)(adas_result.coeffs[i][2] * tmp_y * tmp_y + adas_result.coeffs[i][1]
* tmp_y + adas_result.coeffs[i][0]);
tmp_x = fmin(SVP_BIG_STREAM_W, fmax(0, tmp_x * 3));
tmp_y = fmin(SVP_BIG_STREAM_H, fmax(0, tmp_y * 3));
x = (xmedia_s32)round(tmp_x);
y = (xmedia_s32)round(tmp_y);
sample_svp_draw_thick_pixel(p_yuv_data, SVP_BIG_STREAM_W, SVP_BIG_STREAM_H, x, y, 6);
}
break;
case 1:
y_min = adas_result.row_fitted_result[0][0].y;
y_max = adas_result.row_fitted_result[0][adas_result.lane_fitted_point_num[i] - 1].y;
for (xmedia_s32 k = 0; k < adas_result.lane_fitted_point_num[i]; k++) {
y_min = fmin(y_min, adas_result.row_fitted_result[0][k].y);
y_max = fmax(y_max, adas_result.row_fitted_result[0][k].y);
}
h_s = y_max - y_min;
for (xmedia_s32 k = 0; k < step; k++) {
tmp_y = ((xmedia_float)k / step * h_s + y_min);
tmp_x = (xmedia_float)(adas_result.coeffs[i][2] * tmp_y * tmp_y + adas_result.coeffs[i][1]
* tmp_y + adas_result.coeffs[i][0]);
tmp_x = fmin(SVP_BIG_STREAM_W, fmax(0, tmp_x * 3));
tmp_y = fmin(SVP_BIG_STREAM_H, fmax(0, tmp_y * 3));
x = (xmedia_s32)round(tmp_x);
y = (xmedia_s32)round(tmp_y);
sample_svp_draw_thick_pixel(p_yuv_data, SVP_BIG_STREAM_W, SVP_BIG_STREAM_H, x, y, 6);
}
break;
case 2:
y_min = adas_result.row_fitted_result[1][0].y;
y_max = adas_result.row_fitted_result[1][adas_result.lane_fitted_point_num[i] - 1].y;
for (xmedia_s32 k = 0; k < adas_result.lane_fitted_point_num[i]; k++) {
y_min = fmin(y_min, adas_result.row_fitted_result[1][k].y);
y_max = fmax(y_max, adas_result.row_fitted_result[1][k].y);
}
h_s = y_max - y_min;
for (xmedia_s32 k = 0; k < step; k++) {
tmp_y = ((xmedia_float)k / step * h_s + y_min);
tmp_x = (xmedia_float)(adas_result.coeffs[i][2] * tmp_y * tmp_y + adas_result.coeffs[i][1]
* tmp_y + adas_result.coeffs[i][0]);
tmp_x = fmin(SVP_BIG_STREAM_W, fmax(0, tmp_x * 3));
tmp_y = fmin(SVP_BIG_STREAM_H, fmax(0, tmp_y * 3));
x = (xmedia_s32)round(tmp_x);
y = (xmedia_s32)round(tmp_y);
sample_svp_draw_thick_pixel(p_yuv_data, SVP_BIG_STREAM_W, SVP_BIG_STREAM_H, x, y, 6);
}
break;
case 3:
y_min = adas_result.col_fitted_result[1][0].y;
y_max = adas_result.col_fitted_result[1][adas_result.lane_fitted_point_num[i] - 1].y;
for (xmedia_s32 k = 0; k < adas_result.lane_fitted_point_num[i]; k++) {
y_min = fmin(y_min, adas_result.col_fitted_result[1][k].y);
y_max = fmax(y_max, adas_result.col_fitted_result[1][k].y);
}
h_s = y_max - y_min;
for (xmedia_s32 k = 0; k < step; k++) {
tmp_y = ((xmedia_float)k / step * h_s + y_min);
tmp_x = (xmedia_float)(adas_result.coeffs[i][2] * tmp_y * tmp_y + adas_result.coeffs[i][1]
* tmp_y + adas_result.coeffs[i][0]);
tmp_x = fmin(SVP_BIG_STREAM_W, fmax(0, tmp_x * 3));
tmp_y = fmin(SVP_BIG_STREAM_H, fmax(0, tmp_y * 3));
x = (xmedia_s32)round(tmp_x);
y = (xmedia_s32)round(tmp_y);
sample_svp_draw_thick_pixel(p_yuv_data, SVP_BIG_STREAM_W, SVP_BIG_STREAM_H, x, y, 6);
}
break;
}
}
}
xmedia_mmz_unmap(p_yuv_data);
if (adas_result.car_result.target_num > 0) {
for (xmedia_s32 i = 0; i < adas_result.car_result.target_num; i++) {
x1 = (xmedia_s32)roundf(adas_result.car_result.targets[i].rect.x1 / 2) * 2 * 3;
y1 = (xmedia_s32)roundf(adas_result.car_result.targets[i].rect.y1 / 2) * 2 * 3;
x2 = (xmedia_s32)roundf(adas_result.car_result.targets[i].rect.x2 / 2) * 2 * 3;
y2 = (xmedia_s32)roundf(adas_result.car_result.targets[i].rect.y2 / 2) * 2 * 3;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
adas_result.car_result.targets[i].class_type = XMEDIA_SVP_CLASS_TYPE_CAR;
#ifdef USE_OSD
if (adas_result.car_result.targets[i].special_target == XMEDIA_TRUE) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "d:%.1fcm",
adas_result.car_result.targets[i].distance);
sample_target_osd(&video_frame_big, x1, y1, format_untile_line);
}
#endif
}
sample_svp_draw(&target_rect[0], &video_frame_big, adas_result.car_result);
}
if (adas_result.plate_result.target_num > 0) {
for (xmedia_s32 i = 0; i < adas_result.plate_result.target_num; i++) {
x1 = (xmedia_s32)roundf(adas_result.plate_result.targets[i].rect.x1 / 2) * 2 * 3;
y1 = (xmedia_s32)roundf(adas_result.plate_result.targets[i].rect.y1 / 2) * 2 * 3;
x2 = (xmedia_s32)roundf(adas_result.plate_result.targets[i].rect.x2 / 2) * 2 * 3;
y2 = (xmedia_s32)roundf(adas_result.plate_result.targets[i].rect.y2 / 2) * 2 * 3;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
}
sample_svp_draw(&target_rect[0], &video_frame_big, adas_result.plate_result);
}
if (adas_result.person_result.target_num > 0) {
for (xmedia_s32 i = 0; i < adas_result.person_result.target_num; i++) {
x1 = (xmedia_s32)roundf(adas_result.person_result.targets[i].rect.x1 / 2) * 2 * 3;
y1 = (xmedia_s32)roundf(adas_result.person_result.targets[i].rect.y1 / 2) * 2 * 3;
x2 = (xmedia_s32)roundf(adas_result.person_result.targets[i].rect.x2 / 2) * 2 * 3;
y2 = (xmedia_s32)roundf(adas_result.person_result.targets[i].rect.y2 / 2) * 2 * 3;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
}
sample_svp_draw(&target_rect[0], &video_frame_big, adas_result.person_result);
}
if (adas_result.nmv_result.target_num > 0) {
for (xmedia_s32 i = 0; i < adas_result.nmv_result.target_num; i++) {
x1 = (xmedia_s32)roundf(adas_result.nmv_result.targets[i].rect.x1 / 2) * 2 * 3;
y1 = (xmedia_s32)roundf(adas_result.nmv_result.targets[i].rect.y1 / 2) * 2 * 3;
x2 = (xmedia_s32)roundf(adas_result.nmv_result.targets[i].rect.x2 / 2) * 2 * 3;
y2 = (xmedia_s32)roundf(adas_result.nmv_result.targets[i].rect.y2 / 2) * 2 * 3;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
}
sample_svp_draw(&target_rect[0], &video_frame_big, adas_result.nmv_result);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FIRESMOKE) {
xmedia_svp_yolov8_output fire_result = { 0 };
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &fire_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
if (fire_result.target_num > 0) {
for (xmedia_s32 i = 0; i < fire_result.target_num; i++) {
// if (fire_result->targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_FIRE) {
// // 模拟红外 默认IR_THRES 0.6f
// xmedia_float ir_thres = 0.6;
// if (ir_thres < IR_THRES) {
// continue;
// }
// }
x1 = (xmedia_s32)roundf(fire_result.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(fire_result.targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(fire_result.targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(fire_result.targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
}
sample_svp_draw_v8(&target_rect[0], &video_frame, fire_result);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_GESTURE_RECOGNITION) {
xmedia_svp_gesture_result gesture_result = { 0 };
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &gesture_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
if (gesture_result.result.target_num > 0) {
for (xmedia_s32 i = 0; i < gesture_result.result.target_num; i++) {
x1 = (xmedia_s32)roundf(gesture_result.result.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(gesture_result.result.targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(gesture_result.result.targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(gesture_result.result.targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
#ifdef USE_OSD
if (gesture_result.result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_GESTURE_OK) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "Gesture is OK!!!");
sample_target_osd(&video_frame, x1, y1, format_untile_line);
} else if (gesture_result.result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_GESTURE_THUMB) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "Gesture is Thumb!!!");
sample_target_osd(&video_frame, x1, y1, format_untile_line);
} else if (gesture_result.result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_GESTURE_V) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "Gesture is V!!!");
sample_target_osd(&video_frame, x1, y1, format_untile_line);
} else if (gesture_result.result.targets[i].class_type == XMEDIA_SVP_CLASS_TYPE_GESTURE_PALM) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "Gesture is Palm!!!");
sample_target_osd(&video_frame, x1, y1, format_untile_line);
}
#endif
ret = sample_svp_draw_keypoint(&gesture_result.result.targets[i].kpt[0],
GESTURE_KEYPOINT_LEN,
&video_frame);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_svp_draw_keypoint failed with %#x!\n", ret);
}
}
sample_svp_draw_v8(&target_rect[0], &video_frame, gesture_result.result);
}
} else if(svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_EMOTION) {
xmedia_svp_face_attribute_output attribute_output = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &attribute_output);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_process failed with %#x!\n", ret);
}
if (attribute_output.face_num > 0) {
xmedia_u32 w,h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
for (xmedia_s32 i = 0; i < attribute_output.face_num; i++) {
x1 = (xmedia_s32)roundf(attribute_output.attribute_result[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(attribute_output.attribute_result[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(attribute_output.attribute_result[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(attribute_output.attribute_result[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
#ifdef USE_OSD
xmedia_char str_array[SAMPLE_MAX_STRING_NUM];
if (attribute_output.attribute_result[i].emotion_class == XMEDIA_SVP_CLASS_EMOTION_SMILE) {
snprintf(str_array, sizeof(str_array), "id[%d] | %s",
attribute_output.attribute_result[i].face_tracker_id, "smile");
} else if (attribute_output.attribute_result[i].emotion_class == XMEDIA_SVP_CLASS_EMOTION_NORMAL) {
snprintf(str_array, sizeof(str_array), "id[%d] | %s",
attribute_output.attribute_result[i].face_tracker_id, "normal");
} else {
snprintf(str_array, sizeof(str_array), "id[%d] | %s",
attribute_output.attribute_result[i].face_tracker_id, "unknown");
}
sample_target_osd(&video_frame, x1, y1, str_array);
#endif
}
xmedia_svp_yolov5_output result = {0};
result.target_num = attribute_output.face_num;
sample_svp_draw(&target_rect[0], &video_frame, result);
}
} else if(svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION) {
xmedia_svp_fr_output fr_output = {0};
db_match_result match_result = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &fr_output);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_process failed with %#x!\n", ret);
}
if (svp_info->add_flag == XMEDIA_FALSE && svp_info->delete_flag == XMEDIA_FALSE) {
xmedia_u32 w,h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
for (xmedia_s32 i = 0; i < fr_output.face_num; i++) {
x1 = (xmedia_s32)roundf(fr_output.fr_result[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(fr_output.fr_result[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(fr_output.fr_result[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(fr_output.fr_result[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
}
xmedia_svp_yolov5_output result = {0};
result.target_num = fr_output.face_num;
sample_svp_draw(&target_rect[0], &video_frame, result);
ret = svp_get_match_result(svp_info->g_db_handle, &fr_output, &match_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("svp_get_match_result failed %#x!\n", ret);
}
xmedia_s32 draw_index = 0;
if (match_result.match_num != 0) {
for (xmedia_s32 match_index = 0; match_index < match_result.face_num; match_index++) {
if (strcmp(match_result.match_name[match_index], "") != 0) { // this index got name
#ifndef USE_OSD
SAMPLE_PRT("----------------- finish fr_process, got name :[%s] -----------------\n",
match_result.match_name[match_index]);
#endif
// draw the box that match name
x1 = (xmedia_s32)roundf(fr_output.fr_result[match_index].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(fr_output.fr_result[match_index].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(fr_output.fr_result[match_index].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(fr_output.fr_result[match_index].rect.y2 / 2) * 2;
w = abs(x2 - x1);
h = abs(y2 - y1);
target_rect[draw_index].x = x1;
target_rect[draw_index].y = y1;
target_rect[draw_index].width = w;
target_rect[draw_index].height = h;
draw_index++;
#ifdef USE_OSD
sample_target_osd(&video_frame, x1, y1, match_result.match_name[match_index]);
#endif
}
}
}else {
// SAMPLE_PRT("this frame have not face\n");
}
}
// add someone, one frame only have a face!
if (svp_info->add_flag && fr_output.face_num != 0) {
ret = svp_get_match_result(svp_info->g_db_handle, &fr_output, &match_result);
SAMPLE_PRT("this frame face_num: %d, match_num:%d\n", match_result.face_num, match_result.match_num);
if (match_result.match_num != 0) {
for (xmedia_s32 match_index = 0; match_index < match_result.face_num; match_index++) {
if (strcmp(match_result.match_name[match_index], "") != 0) {
SAMPLE_PRT("人脸已存在，无法录入 :%s\n", match_result.match_name[match_index]);
}
}
}
if (match_result.match_num == 0) {
add_person_info person_info;
person_info.add_person_name = svp_info->add_name;
for (xmedia_s32 add_fea_index = 0; add_fea_index < XMEDIA_SVP_FEATURE_COL; add_fea_index++) {
person_info.add_person_feature[add_fea_index] = fr_output.fr_result[0].vector[add_fea_index];
}
ret = svp_add_someone_to_database(svp_info->g_db_handle, &person_info);
if (ret == XMEDIA_SUCCESS) {
SAMPLE_PRT(" add someone to database success %#x!\n", ret);
} else {
SAMPLE_PRT(" add someone to database failed %#x!\n", ret);
}
}
SAMPLE_PRT("please input q to quit!\n");
g_svp_start_flag = XMEDIA_FALSE;
}
// delete someone
if (svp_info->delete_flag) {
ret = svp_delete_someone_from_database(svp_info->g_db_handle, svp_info->delete_name);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT(" delete someone from databasae failed %#x!\n", ret);
}
SAMPLE_PRT("please input q to quit!\n");
g_svp_start_flag = XMEDIA_FALSE;
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_COMPANION_ROBOT) {
xmedia_svp_petbot_output robot_output = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &robot_output);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
if (robot_output.pet_num > 0) {
xmedia_u32 i, w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_PETBOT_MAX_TARGET * 2]; // 人和宠物
xmedia_svp_yolov5_output yolov5_result = {0};
xmedia_u32 index = 0;
for (i = 0; i < robot_output.pet_num; i++) {
x1 = (xmedia_s32)roundf(robot_output.pet_targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(robot_output.pet_targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(robot_output.pet_targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(robot_output.pet_targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[index].x = x1;
target_rect[index].y = y1;
target_rect[index].width = w;
target_rect[index].height = h;
index++;
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "id[%d]s[%.2f]c[%.2f]d[%.2f]",
robot_output.pet_targets[i].tracker_id, robot_output.pet_targets[i].detect_score,
robot_output.pet_targets[i].classfier_score, robot_output.pet_targets[i].distance);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
}
for (i = 0; i < robot_output.kpt_num; i++) {
x1 = (xmedia_s32)roundf(robot_output.kpt_targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(robot_output.kpt_targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(robot_output.kpt_targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(robot_output.kpt_targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[index].x = x1;
target_rect[index].y = y1;
target_rect[index].width = w;
target_rect[index].height = h;
index++;
}
yolov5_result.target_num = index;
sample_svp_draw(&target_rect[0], &video_frame, yolov5_result);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_DMS) {
xmedia_svp_dms_output dms_result = { 0 };
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &dms_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
if (dms_result.target_num > 0) {
xmedia_s32 i = 0;
#ifdef USE_OSD
xmedia_s32 x1, y1, j = 0;
#endif
for (i = 0; i < dms_result.target_num; i++) {
if (dms_result.targets[i].special_target == XMEDIA_TRUE) {
#ifdef DMS_OPENCV
if (dms_result.targets[i].tracker_id != dms_state.tracker_id) {
dms_state.distract_frame = 0;
dms_state.distract = XMEDIA_FALSE;
dms_state.tracker_id = dms_result.targets[i].tracker_id;
}
// 姿态计算
svp_euler_angles angles = { 0 };
ret = svp_opencv_face_orientation(dms_result.targets[i].kpt, &angles);
dms_state.pitch = (xmedia_float)angles.pitch;
dms_state.yaw = (xmedia_float)angles.yaw;
dms_state.roll = (xmedia_float)angles.roll;
// 分心判断逻辑
if (dms_state.pitch >= 20 ||
dms_state.pitch <= -20 ||
dms_state.roll >= 20 ||
dms_state.roll <= -20 ||
dms_state.yaw >= 20 ||
dms_state.yaw <= -20) {
if (dms_state.distract == XMEDIA_FALSE &&
dms_state.distract_frame >= dms_state.warn_frame) {
dms_state.distract = XMEDIA_TRUE;
}
if (dms_state.distract_frame < dms_state.warn_frame) {
dms_state.distract_frame++;
}
} else {
if (dms_state.distract_frame <= 0) {
dms_state.distract = XMEDIA_FALSE;
}
if (dms_state.distract_frame > 0) {
dms_state.distract_frame--;
}
}
#endif
#ifdef USE_OSD
x1 = (xmedia_s32)roundf(dms_result.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(dms_result.targets[i].rect.y1 / 2) * 2;
xmedia_u8 offset = 0;
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "ID[%d]SCR[%.2f]",
dms_result.targets[i].tracker_id,
dms_result.targets[i].detect_score);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
offset += 16;
if (dms_result.targets[i].dms_report.fatigue_flag == XMEDIA_TRUE) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "fatigue");
sample_target_osd(&video_frame, x1, y1 + offset, format_untile_line);
offset += 16;
}
#ifdef OPENCV
if (dms_state.distract == XMEDIA_TRUE) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "distract");
sample_target_osd(&video_frame, x1, y1 + offset, format_untile_line);
offset += 16;
}
#endif
for (j = 0; j < dms_result.targets[i].dms_report.phone_num; j++) {
if (dms_result.targets[i].dms_report.phone[j].flag == XMEDIA_TRUE) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "phone");
sample_target_osd(&video_frame, x1, y1 + offset, format_untile_line);
offset += 16;
}
}
for (j = 0; j < dms_result.targets[i].dms_report.cigar_num; j++) {
if (dms_result.targets[i].dms_report.cigar[j].flag == XMEDIA_TRUE) {
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "smoke");
sample_target_osd(&video_frame, x1, y1 + offset, format_untile_line);
}
}
#endif
}
ret = sample_svp_draw_keypoint(&dms_result.targets[i].kpt[0],
MAX_DETECT_KEYPOINT_NUM,
&video_frame);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_svp_draw keypoint failed with %#x!\n", ret);
}
}
sample_svp_draw_dms(&dms_result, &video_frame);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION) {
xmedia_svp_plate_reco_output plate_output = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &plate_output);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_process failed with %#x!\n", ret);
}
xmedia_u32 w,h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_svp_yolov5_output draw_output;
xmedia_float scale_x = (xmedia_float)SVP_SMALL_STREAM_W / video_frame_big.frame.width;
xmedia_float scale_y = (xmedia_float)SVP_SMALL_STREAM_H / video_frame_big.frame.height;
xmedia_svp_plate_reco_attr plate_attr;
ret = xmedia_svp_task_get_attr(svp_info->svp_handle, &plate_attr);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_get_attr failed with %#x!\n", ret);
}
sample_draw_zone(&plate_attr.detect_zone, &video_frame);
for (xmedia_s32 i = 0; i < plate_output.target_num; i++) {
append_to_file("./plate_info.log", plate_output.targets[i].plate_char);
SAMPLE_PRT("char: %s score:%.2f color: %d! color_score: %.2f direction: %d [0: forward 1:backward]\n",
plate_output.targets[i].plate_char,
plate_output.targets[i].char_score,
plate_output.targets[i].color,
plate_output.targets[i].color_score,
plate_output.targets[i].lpr_direction);
x1 = (xmedia_s32)roundf(plate_output.targets[i].rect.x1 * scale_x / 2) * 2;
y1 = (xmedia_s32)roundf(plate_output.targets[i].rect.y1 * scale_y / 2) * 2;
x2 = (xmedia_s32)roundf(plate_output.targets[i].rect.x2 * scale_x / 2) * 2;
y2 = (xmedia_s32)roundf(plate_output.targets[i].rect.y2 * scale_y / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
draw_output.targets[i].rect = plate_output.targets[i].rect;
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "id[%d]scr[%.2f]color[%.2f]",
plate_output.targets[i].tracker_id,
plate_output.targets[i].char_score,
plate_output.targets[i].color_score);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
}
draw_output.target_num = plate_output.target_num;
sample_svp_draw(&target_rect[0], &video_frame, draw_output);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION) {
xmedia_svp_vehicle_reco_output veh_output = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &veh_output);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_process failed with %#x!\n", ret);
}
{
xmedia_u32 w,h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_svp_yolov5_output draw_output;
xmedia_float scale_x = (xmedia_float)SVP_SMALL_STREAM_W / video_frame_big.frame.width;
xmedia_float scale_y = (xmedia_float)SVP_SMALL_STREAM_H / video_frame_big.frame.height;
for (xmedia_s32 i = 0; i < veh_output.target_num; i++) {
// SAMPLE_PRT("id:[%d] x:[%.2f] y[%.2f]\n", result.targets[i].tracker_id,
// result.targets[i].rect.x1,result.targets[i].rect.y1);
x1 = (xmedia_s32)roundf(veh_output.targets[i].rect.x1 * scale_x / 2) * 2;
y1 = (xmedia_s32)roundf(veh_output.targets[i].rect.y1 * scale_y / 2) * 2;
x2 = (xmedia_s32)roundf(veh_output.targets[i].rect.x2 * scale_x / 2) * 2;
y2 = (xmedia_s32)roundf(veh_output.targets[i].rect.y2 * scale_y / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
draw_output.targets[i].rect = veh_output.targets[i].rect;
SAMPLE_PRT("tracker_id[%d]x1.y1:[%d,%d] x2,y2:[%d,%d] w[%d] h[%d]\n",
veh_output.targets[i].tracker_id, x1, y1, x2, y2, w, h);
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "id[%d]color[%.2f]type[%.2f]",
veh_output.targets[i].tracker_id,
veh_output.targets[i].color_scr,
veh_output.targets[i].type_scr);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
if (veh_output.targets[i].color == XMEDIA_SVP_VEHICLE_COLOR_WHITE) {
SAMPLE_PRT("WHITE score:%.2f\n", veh_output.targets[i].color_scr);
} else if (veh_output.targets[i].color == XMEDIA_SVP_VEHICLE_COLOR_RED) {
SAMPLE_PRT("RED score:%.2f\n", veh_output.targets[i].color_scr);
} else if (veh_output.targets[i].color == XMEDIA_SVP_VEHICLE_COLOR_YELLOW) {
SAMPLE_PRT("YELLOW score:%.2f\n", veh_output.targets[i].color_scr);
} else if (veh_output.targets[i].color == XMEDIA_SVP_VEHICLE_COLOR_BLACK) {
SAMPLE_PRT("BLACK score:%.2f\n", veh_output.targets[i].color_scr);
} else if (veh_output.targets[i].color == XMEDIA_SVP_VEHICLE_COLOR_BLUE) {
SAMPLE_PRT("BLUE score:%.2f\n", veh_output.targets[i].color_scr);
} else if (veh_output.targets[i].color == XMEDIA_SVP_VEHICLE_COLOR_GREEN) {
SAMPLE_PRT("GREEN score:%.2f\n", veh_output.targets[i].color_scr);
} else {
SAMPLE_PRT("unkown score:%.2f\n", veh_output.targets[i].color_scr);
}
if (veh_output.targets[i].type == XMEDIA_SVP_VEHICLE_TYPE_SEDAN) {
SAMPLE_PRT("小车 score:%.2f\n", veh_output.targets[i].type_scr);
} else if (veh_output.targets[i].type == XMEDIA_SVP_VEHICLE_TYPE_MINIVAN) {
SAMPLE_PRT("小货车 score:%.2f\n", veh_output.targets[i].type_scr);
} else if (veh_output.targets[i].type == XMEDIA_SVP_VEHICLE_TYPE_TRUCK) {
SAMPLE_PRT("卡车 score:%.2f\n", veh_output.targets[i].type_scr);
} else if (veh_output.targets[i].type == XMEDIA_SVP_VEHICLE_TYPE_TANKER) {
SAMPLE_PRT("罐车 score:%.2f\n", veh_output.targets[i].type_scr);
} else if (veh_output.targets[i].type == XMEDIA_SVP_VEHICLE_TYPE_MINIBUS) {
SAMPLE_PRT("巴士 score:%.2f\n", veh_output.targets[i].type_scr);
} else {
SAMPLE_PRT("未知 score:%.2f\n", veh_output.targets[i].type_scr);
}
SAMPLE_PRT("vehicle_direction[%d] {0:forward 1:backward}\n", veh_output.targets[i].vehicle_direction);
}
draw_output.target_num = veh_output.target_num;
sample_svp_draw(&target_rect[0], &video_frame, draw_output);
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO) {
xmedia_svp_plate_vehicle_output pv_output = {0};
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &pv_output);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_process failed with %#x!\n", ret);
}
xmedia_u32 w,h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
xmedia_svp_yolov5_output draw_output;
xmedia_float scale_x = (xmedia_float)SVP_SMALL_STREAM_W / video_frame_big.frame.width;
xmedia_float scale_y = (xmedia_float)SVP_SMALL_STREAM_H / video_frame_big.frame.height;
for (xmedia_s32 i = 0; i < pv_output.target_num; i++) {
append_to_file("./plate_vehicle_info.log", pv_output.targets[i].plate_char);
SAMPLE_PRT("char: %s score:%.2f color: %d! color_type: %.2f direction: %d [0: forward 1:backward]\n",
pv_output.targets[i].plate_char,
pv_output.targets[i].plate_score,
pv_output.targets[i].plate_color,
pv_output.targets[i].plate_color_scr,
pv_output.targets[i].plate_direction);
SAMPLE_PRT("[car_type: %d score:%.2f] [color: %d score: %.2f] direction: %d [0: forward 1:backward]\n",
pv_output.targets[i].veh_type,
pv_output.targets[i].veh_type_scr,
pv_output.targets[i].veh_color,
pv_output.targets[i].veh_color_scr,
pv_output.targets[i].veh_direction);
x1 = (xmedia_s32)roundf(pv_output.targets[i].plate_rect.x1 * scale_x / 2) * 2;
y1 = (xmedia_s32)roundf(pv_output.targets[i].plate_rect.y1 * scale_y / 2) * 2;
x2 = (xmedia_s32)roundf(pv_output.targets[i].plate_rect.x2 * scale_x / 2) * 2;
y2 = (xmedia_s32)roundf(pv_output.targets[i].plate_rect.y2 * scale_y / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
draw_output.targets[i].rect = pv_output.targets[i].plate_rect;
// SAMPLE_PRT("sample_num[%d]x1.y1:[%d,%d] x2,y2:[%d,%d] w[%d] h[%d]\n", i, x1, y1, x2, y2, w, h);
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "id[%d]char[%s]",
pv_output.targets[i].tracker_id,
pv_output.targets[i].plate_char);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
}
draw_output.target_num = pv_output.target_num;
sample_svp_draw(&target_rect[0], &video_frame, draw_output);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_CAR ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PET_V8) {
xmedia_svp_yolov8_output yolov8_result = { 0 };
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &yolov8_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
for (xmedia_s32 i = 0; i < yolov8_result.target_num; i++) {
x1 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "id[%d]score[%.2f]type[%d]",
yolov8_result.targets[i].tracker_id,
yolov8_result.targets[i].detect_score,
yolov8_result.targets[i].class_type);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
}
sample_svp_draw_v8(&target_rect[0], &video_frame, yolov8_result);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_CAR_NMV_FIRE) {
xmedia_svp_yolov8_output yolov8_result = { 0 };
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &yolov8_result);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
for (xmedia_s32 i = 0; i < yolov8_result.target_num; i++) {
x1 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(yolov8_result.targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "cls[%d]score[%.2f]",
yolov8_result.targets[i].class_type,
yolov8_result.targets[i].detect_score);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
}
#ifdef USE_OSD
#ifdef READ_YUV
xmedia_char mark_line[SAMPLE_MAX_STRING_NUM];
memset(mark_line, 0, sizeof(mark_line));
snprintf(mark_line, sizeof(mark_line), "[%d/%d]", file_index, file_count);
sample_target_osd(&video_frame, 320, 8, mark_line);
#endif
#endif
sample_svp_draw_v8(&target_rect[0], &video_frame, yolov8_result);
} else {
xmedia_svp_yolov5_output result = { 0 };
#ifdef SAMPLE_TIME_DEBUG
TIME_COST_START();
#endif
ret = xmedia_svp_task_process(svp_info->svp_handle, &task_input, &result);
#ifdef SAMPLE_TIME_DEBUG
TIME_COST_END();
TIME_COST_PRINT("svp process all");
#endif
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
if (result.target_num > 0) {
#if 0
SAMPLE_PRT(" target num :[%d] \n", result.target_num);
#endif
xmedia_u32 w, h;
xmedia_s32 x1, y1, x2, y2;
xmedia_video_rect target_rect[XMEDIA_SVP_MAX_TARGET_NUM];
for (xmedia_s32 i = 0; i < result.target_num; i++) {
#if 0
printf("target[%d] id[%d] x[%.2f] y[%.2f] s[%.2f]c[%.2f] \n", i,
result.targets[i].tracker_id,
result.targets[i].rect.x1,
result.targets[i].rect.y1,
result.targets[i].detect_score,
result.targets[i].classfier_score);
#endif
x1 = (xmedia_s32)roundf(result.targets[i].rect.x1 / 2) * 2;
y1 = (xmedia_s32)roundf(result.targets[i].rect.y1 / 2) * 2;
x2 = (xmedia_s32)roundf(result.targets[i].rect.x2 / 2) * 2;
y2 = (xmedia_s32)roundf(result.targets[i].rect.y2 / 2) * 2;
w = ABS(x2 - x1);
h = ABS(y2 - y1);
target_rect[i].x = x1;
target_rect[i].y = y1;
target_rect[i].width = w;
target_rect[i].height = h;
#ifdef USE_OSD
xmedia_char format_untile_line[SAMPLE_MAX_STRING_NUM];
snprintf(format_untile_line, sizeof(format_untile_line), "id[%d]scr[%.2f]cls[%.2f]mv[%d]",
result.targets[i].tracker_id,
result.targets[i].detect_score,
result.targets[i].classfier_score,
result.targets[i].motion_state);
sample_target_osd(&video_frame, x1, y1, format_untile_line);
#endif
}
sample_svp_draw(&target_rect[0], &video_frame, result);
}
}
ret = xmedia_venc_send_frame(svp_info->venc_chn[1], &video_frame, milli_sec);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
if (svp_info->big_stream == XMEDIA_TRUE) {
ret = xmedia_venc_send_frame(svp_info->venc_chn[2], &video_frame_big, milli_sec);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_send_frame failed with %#x!\n", ret);
}
}
ret = xmedia_vpss_release_ochn_frame(svp_info->vpss_pipe, svp_info->vpss_ochn[1], &video_frame);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vpss_release_ochn_frame failed with %#x!\n", ret);
}
if (svp_info->big_stream == XMEDIA_TRUE) {
ret = xmedia_vpss_release_ochn_frame(svp_info->vpss_pipe, svp_info->vpss_ochn[2], &video_frame_big);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vpss_release_ochn_frame failed with %#x!\n", ret);
}
}
memset(&video_frame, 0, sizeof(xmedia_video_frame_info));
memset(&video_frame_big, 0, sizeof(xmedia_video_frame_info));
#ifdef READ_YUV
if (input_file_flag && file_index >= file_count) {
break;
}
#endif
}
SAMPLE_PRT("exit svp thread...\n");
return NULL;
}
static xmedia_s32 sample_mmz_alloc_and_map(const xmedia_char *mmz_name, xmedia_char *buf_name,
xmedia_u64 *phy_addr, xmedia_void **virt_addr, xmedia_u32 size)
{
*phy_addr = xmedia_mmz_alloc(mmz_name, buf_name, size);
if (*phy_addr != XMEDIA_NULL) {
*virt_addr = xmedia_mmz_map(*phy_addr, size, XMEDIA_FALSE);
if (*virt_addr == XMEDIA_NULL) {
SAMPLE_PRT("xmedia_mmz_map filed, size %d \n", size);
xmedia_mmz_free(*phy_addr);
return XMEDIA_FAILURE;
}
} else {
SAMPLE_PRT("xmedia_mmz_alloc filed, size %d \n", size);
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_mmz_alloc_and_map_cache(const xmedia_char *mmz_name, xmedia_char *buf_name,
xmedia_u64 *phy_addr, xmedia_void **virt_addr, xmedia_u32 size)
{
*phy_addr = xmedia_mmz_alloc(mmz_name, buf_name, size);
if (*phy_addr != XMEDIA_NULL) {
*virt_addr = xmedia_mmz_map(*phy_addr, size, XMEDIA_TRUE);
if (*virt_addr == XMEDIA_NULL) {
SAMPLE_PRT("xmedia_mmz_map filed, size %d \n", size);
xmedia_mmz_free(*phy_addr);
return XMEDIA_FAILURE;
}
} else {
SAMPLE_PRT("xmedia_mmz_alloc filed, size %d \n", size);
return XMEDIA_FAILURE;
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_mmz_unmap_and_free(xmedia_u64 phy_addr, xmedia_void *virt_addr)
{
if (virt_addr != XMEDIA_NULL) {
xmedia_mmz_unmap(virt_addr);
}
xmedia_mmz_free(phy_addr);
}
xmedia_s32 sample_svp_query_mem_size(xmedia_svp_modules *modules, xmedia_u8 module_num, sample_svp_mem_size *max_size)
{
xmedia_s32 ret;
xmedia_cl_mem_info model_mem_info[module_num];
for (xmedia_s32 i = 0; i < module_num; i++) {
// 查询多个模型所需要的内存的最大值
ret = xmedia_cl_graph_query_model_info_from_file(modules[i].pathname, &model_mem_info[i], XMEDIA_CL_MEM_INFO);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_cl_graph_query_model_info_from_file error ret : %d\n", ret);
return XMEDIA_FAILURE;
}
if (max_size->work < model_mem_info[i].worksize) {
max_size->work= model_mem_info[i].worksize;
}
if (max_size->input < model_mem_info[i].inputsize) {
max_size->input = model_mem_info[i].inputsize;
}
if (max_size->output < model_mem_info[i].outputsize) {
max_size->output = model_mem_info[i].outputsize;
}
}
return ret;
}
xmedia_s32 sample_svp_set_config(sample_svp_mem_size *max_size)
{
xmedia_s32 ret;
ret = xmedia_svp_get_config(&g_svp_cfg);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_get_config error ret : %d\n", ret);
return XMEDIA_FAILURE;
}
// sample默认不设置内存复用，默认值MAX，根据具体使用场景选择下列情况设置内存复用情况
g_svp_cfg.reuse_type = XMEDIA_SVP_MEM_TYPE_MAX;
// 正常内存复用，目前使用这个分支，申请work、input、output内存，reuse_type设置为BLOCK模式
// g_svp_cfg.reuse_type = XMEDIA_SVP_MEM_TYPE_BLOCK;
// AINR内存复用，此处不申请work内存，在AINR内存申请处使用xmedia_cl_set_workspace_addr，需要在这里申请input和output内存
// g_svp_cfg.reuse_type = XMEDIA_SVP_MEM_TYPE_AINR_SHARE;
// 仅使用三合一内存模型，不与其他模型并行时，设置为COMPLETE模式，当前仅在人车合一模型上实现
// g_svp_cfg.reuse_type = XMEDIA_SVP_MEM_TYPE_COMPLETE;
switch (g_svp_cfg.reuse_type) {
case XMEDIA_SVP_MEM_TYPE_MAX:
// 保持默认，初始化为0
break;
case XMEDIA_SVP_MEM_TYPE_BLOCK:
g_svp_cfg.workbuf_reuse_mem.size = max_size->work;
g_svp_cfg.input_reuse_mem.size = max_size->input;
g_svp_cfg.output_reuse_mem.size = max_size->output;
// work、input、output分别共用
ret = sample_mmz_alloc_and_map(XMEDIA_NULL, "svp_npu_work",
&(g_svp_cfg.workbuf_reuse_mem.phyaddr),
(xmedia_void**)(&(g_svp_cfg.workbuf_reuse_mem.viraddr)),
g_svp_cfg.workbuf_reuse_mem.size);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_mmz_alloc_and_map svp_npu_work_mem errno: %d\n", ret);
return XMEDIA_FAILURE;
}
ret = sample_mmz_alloc_and_map(XMEDIA_NULL, "svp_npu_input",
&(g_svp_cfg.input_reuse_mem.phyaddr),
(xmedia_void**)(&(g_svp_cfg.input_reuse_mem.viraddr)),
g_svp_cfg.input_reuse_mem.size);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_mmz_alloc_and_map svp_npu_input_mem errno: %d\n", ret);
goto EXIT0;
}
ret = sample_mmz_alloc_and_map_cache(XMEDIA_NULL, "svp_npu_output",
&(g_svp_cfg.output_reuse_mem.phyaddr),
(xmedia_void**)(&(g_svp_cfg.output_reuse_mem.viraddr)),
g_svp_cfg.output_reuse_mem.size);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_mmz_alloc_and_map svp_npu_output_mem errno: %d\n", ret);
goto EXIT1;
}
break;
case XMEDIA_SVP_MEM_TYPE_AINR_SHARE:
g_svp_cfg.workbuf_reuse_mem.size = 0;
g_svp_cfg.input_reuse_mem.size = max_size->input;
g_svp_cfg.output_reuse_mem.size = max_size->output;
// input、output分别共用
ret = sample_mmz_alloc_and_map(XMEDIA_NULL, "svp_npu_input",
&(g_svp_cfg.input_reuse_mem.phyaddr),
(xmedia_void**)(&(g_svp_cfg.input_reuse_mem.viraddr)),
g_svp_cfg.input_reuse_mem.size);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_mmz_alloc_and_map svp_npu_input_mem errno: %d\n", ret);
goto EXIT0;
}
ret = sample_mmz_alloc_and_map_cache(XMEDIA_NULL, "svp_npu_output",
&(g_svp_cfg.output_reuse_mem.phyaddr),
(xmedia_void**)(&(g_svp_cfg.output_reuse_mem.viraddr)),
g_svp_cfg.output_reuse_mem.size);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_mmz_alloc_and_map svp_npu_output_mem errno: %d\n", ret);
goto EXIT1;
}
break;
case XMEDIA_SVP_MEM_TYPE_COMPLETE:
g_svp_cfg.workbuf_reuse_mem.size = max_size->work;
// work、input、output三合一共用
ret = sample_mmz_alloc_and_map(XMEDIA_NULL, "svp_npu_work",
&(g_svp_cfg.workbuf_reuse_mem.phyaddr),
(xmedia_void**)(&(g_svp_cfg.workbuf_reuse_mem.viraddr)),
g_svp_cfg.workbuf_reuse_mem.size);
if (XMEDIA_SUCCESS != ret) {
SAMPLE_PRT("sample_mmz_alloc_and_map svp_npu_work_mem errno: %d\n", ret);
return XMEDIA_FAILURE;
}
break;
}
ret = xmedia_svp_set_config(&g_svp_cfg);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_set_config error ret : %d\n", ret);
goto EXIT2; // 若异常，按照实际走的分支，释放已申请的内存
}
return ret;
EXIT2:
if (g_svp_cfg.output_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.output_reuse_mem.phyaddr, g_svp_cfg.output_reuse_mem.viraddr);
}
EXIT1:
if (g_svp_cfg.input_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.input_reuse_mem.phyaddr, g_svp_cfg.input_reuse_mem.viraddr);
}
EXIT0:
if (g_svp_cfg.workbuf_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.workbuf_reuse_mem.phyaddr, g_svp_cfg.workbuf_reuse_mem.viraddr);
}
return XMEDIA_FAILURE;
}
static xmedia_void sample_svp_free_reusemem()
{
if (g_svp_cfg.reuse_type == XMEDIA_SVP_MEM_TYPE_BLOCK) {
if (g_svp_cfg.output_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.output_reuse_mem.phyaddr, g_svp_cfg.output_reuse_mem.viraddr);
}
if (g_svp_cfg.input_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.input_reuse_mem.phyaddr, g_svp_cfg.input_reuse_mem.viraddr);
}
// 如果workspace的内存还与其他算法或者模块共用，可以不在此处释放，在程序最后结束时释放
if (g_svp_cfg.workbuf_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.workbuf_reuse_mem.phyaddr, g_svp_cfg.workbuf_reuse_mem.viraddr);
}
} else if (g_svp_cfg.reuse_type == XMEDIA_SVP_MEM_TYPE_AINR_SHARE) {
if (g_svp_cfg.output_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.output_reuse_mem.phyaddr, g_svp_cfg.output_reuse_mem.viraddr);
}
if (g_svp_cfg.input_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.input_reuse_mem.phyaddr, g_svp_cfg.input_reuse_mem.viraddr);
}
} else if (g_svp_cfg.reuse_type == XMEDIA_SVP_MEM_TYPE_COMPLETE) {
if (g_svp_cfg.workbuf_reuse_mem.phyaddr != XMEDIA_NULL) {
sample_mmz_unmap_and_free(g_svp_cfg.workbuf_reuse_mem.phyaddr, g_svp_cfg.workbuf_reuse_mem.viraddr);
}
}
}
xmedia_s32 sample_svp_stop(sample_svp_info *svp_info)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
g_svp_start_flag = XMEDIA_FALSE;
usleep(200000);
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION) {
svp_deinit_database(svp_info->g_db_handle);
}
ret = xmedia_svp_task_destroy(svp_info->svp_handle);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_destroy failed with %d!!! \n", ret);
}
svp_info->svp_handle = -1;
sample_svp_free_reusemem();
xmedia_svp_uninit();
SAMPLE_PRT("svp_stop successfully!!! \n");
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_svp_start(sample_svp_info *svp_info)
{
xmedia_s32 ret;
xmedia_u8 module_num = 0;
xmedia_svp_task_cfg task_cfg;
xmedia_svp_modules modules[8];
sample_svp_mem_size max_size = { 0 };
/*
请先在此接口，加载后面所有可能会用到的模型，提前查询所需的内存大小，此接口不依赖svp和cl的init，可以在任意处使用
若复用workspace，可以提前单独申请workspace，例如AINR模式，sample_svp_set_config无需再申请workspace
但是需要使用xmedia_cl_set_workspace_addr接口
*/
modules[0].pathname = "./model/gnn_person_detect_640x360_rgb888hwc_v0103_20260105.bin";
modules[1].pathname = "./model/gnn_car_detect_640x360_rgb888hwc_v0104_20260126.bin";
modules[2].pathname = "./model/gnn_pet_detect_640x360_rgb888hwc_v0104_20251209.bin";
module_num = 3;
ret = sample_svp_query_mem_size(modules, module_num, &max_size);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_svp_query_mem_size error ret : %d\n", ret);
return XMEDIA_FAILURE;
}
ret = xmedia_svp_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_init error.\n");
return XMEDIA_FAILURE;
}
// 在此处，申请、设置SVP所需的内存大小和地址，后续切换模型无需重复申请内存
ret = sample_svp_set_config(&max_size);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_svp_set_config error ret : %d\n", ret);
return XMEDIA_FAILURE;
}
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_RCNN) {
ret = xmedia_venc_enable_svc(0, XMEDIA_TRUE);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_enable_svc fail.\n");
}
}
switch (svp_info->detect_type) {
case SAMPLE_SVP_ALG_TYPE_PERSON:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_person_detect_640x360_rgb888hwc_v0103_20260105.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
#if CHECK_SVP_SVC
xmedia_venc_svc_param svc_param;
ret = xmedia_venc_get_svc_param(0, &svc_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_get_svc_param fail.\n");
}
svc_param.bg_region.qpmap_value_p = 0x80;
svc_param.bg_region.qpmap_value_i = 0x80;
ret = xmedia_venc_set_svc_param(0, &svc_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_venc_set_svc_param fail.\n");
}
#endif
break;
case SAMPLE_SVP_ALG_TYPE_PERSON_KEYPOINT:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON_KEYPOINT;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_person_keypoint_640x360_rgb888hwc_v0101_20250523.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT_AND_KEYPOINT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_FACE:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_FACE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_face_detect_640x360_rgb888hwc_v0104_20260126.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PET:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PET;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pet_detect_640x360_rgb888hwc_v0104_20251209.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_CAR:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_CAR;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_car_detect_640x360_rgb888hwc_v0104_20260126.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_NON_MOTORIZED_VEHICLE:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_NON_MOTORIZED_VEHICLE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_nocar_detect_640x360_rgb888hwc_v0103_20260126.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_HEAD:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_HEAD;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_head_detect_640x360_rgb888hwc_v0102_20240318.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_FIREWORKS:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_FIREWORKS;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_fireworks_detect_640x360_rgb888hwc_v0101_20250523.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PACKAGE:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PACKAGE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_package_detect_640x360_rgb888hwc_v0102_20260106.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_AOV_PERSON:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_aov_person_detect_640x360_rgb888hwc_v0101_20240909.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_AOV;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_ADAS:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_DETECT;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_license_plate_detection_rgb888hwc_v0101_20241205.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_NON_MOTORIZED_VEHICLE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_nocar_detect_640x360_rgb888hwc_v0103_20260126.bin";
modules[2].alg_type = XMEDIA_SVP_ALG_TYPE_CAR;
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_car_detect_640x360_rgb888hwc_v0104_20260126.bin";
modules[3].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[3].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[3].pathname = "./model/gnn_laneline_detect_640x360_rgb888hwc_v0101_20250616.bin";
modules[4].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
modules[4].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[4].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[4].pathname = "./model/gnn_person_detect_640x360_rgb888hwc_v0103_20260105.bin";
task_cfg.module_num = 5;
task_cfg.task_type = XMEDIA_SVP_TASK_ADAS;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_FIRESMOKE:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_FIRESMOKE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_fire_detect_640x360_rgb888hwc_v0101_20250313.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_FIRE;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_GESTURE_RECOGNITION:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_GESTURE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_gesture_detection_640x360_rgb888hwc_v0101_20241011.bin";
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_gesture_classification_96x96_rgb888hwc_v0101_20241203.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_GESTURE;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_FACE_EMOTION:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_FACE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_face_detect_640x360_rgb888hwc_v0104_20260126.bin";
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_face_keypoint_48x48_rgb888hwc_v0101_20250818.bin";
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_face_emotion_112x112_rgb888hwc_v0101_20250904.bin";
task_cfg.module_num = 3;
task_cfg.task_type = XMEDIA_SVP_TASK_EMOTION_CLASSIFITION;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_FACE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_face_detect_640x360_rgb888hwc_v0104_20260126.bin";
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_face_keypoint_48x48_rgb888hwc_v0101_20250818.bin";
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_face_recognition_112x112_rgb888hwc_v0101_20250818.bin";
task_cfg.module_num = 3;
task_cfg.task_type = XMEDIA_SVP_TASK_FACE_RECOGNITON;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PERSON_RCNN:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_person_detect_640x360_rgb888hwc_v0103_20260105.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_SECOND_STAGE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_second_stage_128x128_rgb888hwc_v0104_20260303.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_RCNN;
task_cfg.modules = modules;
#if CHECK_SVP_SMART_AE
xmedia_ae_smart_exposure_attr smart_exp_attr;
xmedia_ae_get_smart_exposure_attr(0, &smart_exp_attr);
smart_exp_attr.enable = XMEDIA_TRUE;
smart_exp_attr.smart_exp_type = XMEDIA_VIDEO_OPERATION_MODE_AUTO;
smart_exp_attr.iso_num = 1;
smart_exp_attr.luma_target[0] = 20;
smart_exp_attr.exp_coef_min = 128;
smart_exp_attr.exp_coef_max = 256 * 200;
smart_exp_attr.ir_mode = XMEDIA_FALSE;
smart_exp_attr.smart_speed = 64;
smart_exp_attr.smart_delay_num = 64;
xmedia_ae_set_smart_exposure_attr(0, &smart_exp_attr);
#endif
break;
case SAMPLE_SVP_ALG_TYPE_CAR_RCNN:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_CAR;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_car_detect_640x360_rgb888hwc_v0104_20260126.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_SECOND_STAGE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_second_stage_128x128_rgb888hwc_v0104_20260303.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_RCNN;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PET_RCNN:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PET;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pet_detect_640x360_rgb888hwc_v0104_20251209.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_SECOND_STAGE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_second_stage_128x128_rgb888hwc_v0104_20260303.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_RCNN;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_COMPANION_ROBOT:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PET;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pet_robot_detect_640x360_rgb888hwc_v0103_20250520.bin";
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_pet_robot_classify_128x128_rgb888hwc_v0101_20250926.bin";
modules[2].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON_KEYPOINT;
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_person_keypoint_640x360_rgb888hwc_v0101_20250523.bin";
task_cfg.module_num = 3;
task_cfg.task_type = XMEDIA_SVP_TASK_COMPANION_ROBOT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PERSON_RCNN_720P:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_person_nocar_detect_1280x720_rgb888hwc_v0101_202507025.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_SECOND_STAGE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_second_stage_128x128_rgb888hwc_v0104_20260303.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_RCNN_720P;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_CAR_RCNN_720P:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_CAR;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_car_detect_1280x720_rgb888hwc_v0101_20251103.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_SECOND_STAGE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_second_stage_128x128_rgb888hwc_v0104_20260303.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_RCNN_720P;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PET_RCNN_720P:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PET;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pet_detect_1280x720_rgb888hwc_v0101_20251103.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_SECOND_STAGE;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_second_stage_128x128_rgb888hwc_v0104_20260303.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_RCNN_720P;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_MULTI_DETECT:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PET;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pet_detect_640x360_rgb888hwc_v0104_20251209.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_CAR;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_car_detect_640x360_rgb888hwc_v0104_20260126.bin";
modules[2].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON;
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_person_detect_640x360_rgb888hwc_v0103_20260105.bin";
task_cfg.module_num = 3;
task_cfg.task_type = XMEDIA_SVP_TASK_MULTI_DETECT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PERSON_CAR:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PERSON_CAR;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
// 内存三合一模型，搭配内存三合一COMPLETE模式使用
// modules[0].pathname = "./model/gnn_person_car_detect_640x360_rgb888hwc_reuse_v0101_20251226.bin";
modules[0].pathname = "./model/gnn_person_car_detect_yolov8_640x360_rgb888hwc_v0101_20260210.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT_AND_KEYPOINT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_DMS:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_DMS;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_dms_640x360_rgb888hwc_v0101_20240906.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DMS;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_DETECT;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_plate_detect_512x288_rgb888hwc_v0101_20241205.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_RECO;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_plate_recognition_192x48_rgb888hwc_v0101_20251125.bin";
modules[2].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_COLOR;
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_plate_color_192x48_rgb888hwc_v0101_20251123.bin";
#define PLATE_GATE
#ifdef PLATE_GATE
modules[3].alg_type = XMEDIA_SVP_ALG_TYPE_VEHICLE_DETECT;
modules[3].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[3].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[3].pathname = "./model/gnn_vehicle_detect_384x224_rgb888hwc_v0101_20240930.bin";
task_cfg.module_num = 4;
#else
task_cfg.module_num = 3;
#endif
task_cfg.task_type = XMEDIA_SVP_TASK_PLATE;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_VEHICLE_DETECT;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_vehicle_detect_384x224_rgb888hwc_v0101_20240930.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_VEHICLE_RECO;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_vehicle_recognition_224x224_rgb888hwc_v0101_20240930.bin";
task_cfg.module_num = 2;
task_cfg.task_type = XMEDIA_SVP_TASK_VEHICLE;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_DETECT;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_plate_detect_512x288_rgb888hwc_v0101_20241205.bin";
modules[1].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_RECO;
modules[1].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[1].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[1].pathname = "./model/gnn_plate_recognition_192x48_rgb888hwc_v0101_20251125.bin";
modules[2].alg_type = XMEDIA_SVP_ALG_TYPE_LICENSE_COLOR;
modules[2].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[2].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[2].pathname = "./model/gnn_plate_color_192x48_rgb888hwc_v0101_20251123.bin";
modules[3].alg_type = XMEDIA_SVP_ALG_TYPE_VEHICLE_DETECT;
modules[3].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[3].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[3].pathname = "./model/gnn_vehicle_detect_384x224_rgb888hwc_v0101_20240930.bin";
modules[4].alg_type = XMEDIA_SVP_ALG_TYPE_VEHICLE_RECO;
modules[4].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[4].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[4].pathname = "./model/gnn_vehicle_recognition_224x224_rgb888hwc_v0101_20240930.bin";
task_cfg.module_num = 5;
task_cfg.task_type = XMEDIA_SVP_TASK_PLATE_VEHICLE;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PET_V8:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PET;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pet_detect_yolov8_640x360_rgb888hwc_v0101_20260209.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_DETECT_AND_KEYPOINT;
task_cfg.modules = modules;
break;
case SAMPLE_SVP_ALG_TYPE_PERSON_CAR_NMV_FIRE:
modules[0].alg_type = XMEDIA_SVP_ALG_TYPE_PCNMV_FIRE;
modules[0].load_mode = XMEDIA_SVP_MODEL_FILE;
modules[0].format = XMEDIA_SVP_INPUTDATA_FORMAT_RGB888;
modules[0].pathname = "./model/gnn_pcnmv_fire_detect_640x360_rgb888hwc_v0104_20260310.bin";
task_cfg.module_num = 1;
task_cfg.task_type = XMEDIA_SVP_TASK_PCNMV_FIRE;
task_cfg.modules = modules;
break;
default:
SAMPLE_PRT("detect type not supported! \n");
sample_svp_free_reusemem();
xmedia_svp_uninit();
return XMEDIA_FAILURE;
}
ret = xmedia_svp_task_create(&svp_info->svp_handle, task_cfg);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_create error ret : %d\n", ret);
sample_svp_free_reusemem();
xmedia_svp_uninit();
return XMEDIA_FAILURE;
}
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_AOV_PERSON) {
xmedia_svp_aov_attr yolov5_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov5_attr);
yolov5_attr.detect_threshold = 0.8f;
yolov5_attr.classifier_threshold = 0.01f;
yolov5_attr.iou_threshold = 0.45f;
yolov5_attr.max_target_num = 10;
yolov5_attr.bytetrack_enable = XMEDIA_FALSE;
yolov5_attr.motionless_filter_enable = XMEDIA_FALSE;
yolov5_attr.aov_only_target = XMEDIA_TRUE;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov5_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_KEYPOINT) {
xmedia_svp_yolov8_attr yolov8_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov8_attr);
yolov8_attr.detect_threshold = 0.5f;
yolov8_attr.classifier_threshold = 0.01f;
yolov8_attr.iou_threshold = 0.45f;
yolov8_attr.max_target_num = 10;
yolov8_attr.bytetrack_enable = XMEDIA_FALSE;
yolov8_attr.motionless_filter_enable = XMEDIA_FALSE;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov8_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_ADAS) {
xmedia_svp_adas_attr adas_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &adas_attr);
adas_attr.car_attr.detect_threshold = 0.6f;
adas_attr.car_attr.iou_threshold = 0.4f;
adas_attr.car_attr.max_target_num = 5;
adas_attr.car_attr.classifier_threshold = 0.01;
adas_attr.plate_attr.detect_threshold = 0.5f;
adas_attr.plate_attr.iou_threshold = 0.4f;
adas_attr.plate_attr.max_target_num = 5;
adas_attr.plate_attr.classifier_threshold = 0.01;
adas_attr.person_attr.detect_threshold = 0.5f;
adas_attr.person_attr.iou_threshold = 0.4f;
adas_attr.person_attr.max_target_num = 5;
adas_attr.person_attr.classifier_threshold = 0.01;
adas_attr.nmv_attr.detect_threshold = 0.5f;
adas_attr.nmv_attr.iou_threshold = 0.4f;
adas_attr.nmv_attr.max_target_num = 5;
adas_attr.nmv_attr.classifier_threshold = 0.01;
adas_attr.distance_attr.focal_length_px = 500;
adas_attr.distance_attr.car_limit_angle = 10;
adas_attr.distance_attr.camera_height = 100;
adas_attr.distance_attr.plate_width = 14;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &adas_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FIRESMOKE) {
xmedia_svp_fire_attr fire_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &fire_attr);
fire_attr.detect_attr.detect_threshold = 0.4f;
fire_attr.detect_attr.iou_threshold = 0.5f;
fire_attr.detect_attr.max_target_num = 10;
fire_attr.detect_attr.classifier_threshold = 0.01;
fire_attr.fire_change_ratio = 0.01f;
fire_attr.fire_loss_count = 10;
fire_attr.fire_ratio_sum = 0.1f;
fire_attr.smoke_apear_count = 3;
fire_attr.smoke_change_ratio = 0.1f;
fire_attr.smoke_loss_count = 5;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &fire_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_GESTURE_RECOGNITION) {
xmedia_svp_yolov8_attr gesture_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &gesture_attr);
gesture_attr.bytetrack_enable = XMEDIA_FALSE;
gesture_attr.detect_threshold = 0.5f;
gesture_attr.iou_threshold = 0.5f;
gesture_attr.max_target_num = 3;
gesture_attr.classifier_threshold = 0.01;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &gesture_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION) {
xmedia_svp_fr_attr fr_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &fr_attr);
fr_attr.detect_attr.detect_threshold = 0.5f; // 检测阶段，检测阈值，越低越灵敏
// 检测阶段，分类阈值，默认设置0.01，预留二阶段判断使用
fr_attr.detect_attr.classifier_threshold = 0.01f;
// 检测阶段，相交阈值，越小越容易判断相交，两者相交，分数低的会被过滤
fr_attr.detect_attr.iou_threshold = 0.45f;
fr_attr.detect_attr.max_target_num = 10; // 单帧最大目标数
fr_attr.detect_attr.bytetrack_enable = XMEDIA_TRUE; // 追踪开关，开启追踪后会赋值追踪ID
fr_attr.detect_attr.motionless_filter_enable = XMEDIA_FALSE; // 暂不支持
fr_attr.luma_score = 40; // 识别阶段，人脸亮度阈值，小于阈值的人脸则被过滤
fr_attr.ive_sobel_score = 20; // 识别阶段，人脸模糊的阈值，小于阈值过滤
fr_attr.keypoint_score = 0.8f; // 识别阶段，人脸关键点阈值，小于阈值过滤
fr_attr.fr_pose_attr.clockwise_thres = 40.0f; // 识别阶段，人脸姿态，右歪头阈值，大于阈值过滤
fr_attr.fr_pose_attr.anticlockwise_thres = 40.0f; // 识别阶段，人脸姿态，左歪头阈值，大于阈值过滤
fr_attr.fr_pose_attr.left_thres = 40.0f; // 识别阶段，人脸姿态，左转头阈值，大于阈值过滤
fr_attr.fr_pose_attr.right_thres = 40.0f; // 识别阶段，人脸姿态，右转头阈值，大于阈值过滤
fr_attr.fr_pose_attr.upward_thres = 40.0f; // 识别阶段，人脸姿态，上抬头阈值，大于阈值过滤
fr_attr.fr_pose_attr.downward_thres = 40.0f; // 识别阶段，人脸姿态，下低头阈值，大于阈值过滤
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &fr_attr);
// 数据库初始化
config_info db_cfg;
db_cfg.file_name = "./res/face_feature_data.txt";
db_cfg.match_thres = 0.25; // 识别阶段，与人脸数据库对比的阈值，越大越容易匹配
ret = svp_init_database(&svp_info->g_db_handle, &db_cfg);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("database_init failed ! \n");
}
printf("已进入人脸识别模式,请输入具体的功能: 1:识别 2: 录入 3: 删除\n");
xmedia_s32 input_number;
scanf("%d", &input_number);
if (input_number == 1) {
printf("开始识别\n");
} else if (input_number == 2) {
printf("请输入要添加的人名:\n");
scanf("%s", svp_info->add_name);
printf("确认输入的名字：[%s] ,面对镜头 \n", svp_info->add_name);
svp_info->add_flag = XMEDIA_TRUE;
} else if (input_number == 3) {
printf("请输入要删除的人名:\n");
scanf("%s", svp_info->delete_name);
printf("确认输入的名字：%s\n", svp_info->delete_name);
svp_info->delete_flag = XMEDIA_TRUE;
} else {
printf("开始识别\n");
}
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE_EMOTION) {
xmedia_svp_fr_attr fr_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &fr_attr);
fr_attr.detect_attr.detect_threshold = 0.5f; // 检测阶段，检测阈值，越低越灵敏
// 检测阶段，分类阈值，默认设置0.01，预留二阶段判断使用
fr_attr.detect_attr.classifier_threshold = 0.01f;
// 检测阶段，相交阈值，越小越容易判断相交，两者相交，分数低的会被过滤
fr_attr.detect_attr.iou_threshold = 0.45f;
fr_attr.detect_attr.max_target_num = 10; // 单帧最大目标数
fr_attr.detect_attr.bytetrack_enable = XMEDIA_TRUE; // 追踪开关，开启追踪后会赋值追踪ID
fr_attr.detect_attr.motionless_filter_enable = XMEDIA_FALSE; // 暂不支持
fr_attr.luma_score = 40; // 识别阶段，人脸亮度阈值，小于阈值的人脸则被过滤
fr_attr.ive_sobel_score = 10; // 识别阶段，人脸模糊的阈值，小于阈值过滤
fr_attr.keypoint_score = 0.6f; // 识别阶段，人脸关键点阈值，小于阈值过滤
fr_attr.fr_pose_attr.clockwise_thres = 40.0f; // 识别阶段，人脸姿态，右歪头阈值，大于阈值过滤
fr_attr.fr_pose_attr.anticlockwise_thres = 40.0f; // 识别阶段，人脸姿态，左歪头阈值，大于阈值过滤
fr_attr.fr_pose_attr.left_thres = 40.0f; // 识别阶段，人脸姿态，左转头阈值，大于阈值过滤
fr_attr.fr_pose_attr.right_thres = 40.0f; // 识别阶段，人脸姿态，右转头阈值，大于阈值过滤
fr_attr.fr_pose_attr.upward_thres = 40.0f; // 识别阶段，人脸姿态，上抬头阈值，大于阈值过滤
fr_attr.fr_pose_attr.downward_thres = 40.0f; // 识别阶段，人脸姿态，下低头阈值，大于阈值过滤
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &fr_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_RCNN ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_CAR_RCNN ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PET_RCNN) {
xmedia_svp_yolov5_attr yolov5_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov5_attr);
yolov5_attr.detect_threshold = 0.3f;
yolov5_attr.classifier_threshold = 0.5f;
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.stillness_thres = 0.95f;
yolov5_attr.movement_fps_thres = 7;
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_RCNN) {
yolov5_attr.smart_ae_enable = XMEDIA_TRUE;
yolov5_attr.smart_venc_enable = XMEDIA_TRUE;
yolov5_attr.smart_ae_array[0] = XMEDIA_TRUE;
yolov5_attr.smart_venc_array[0] = XMEDIA_TRUE;
}
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov5_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_COMPANION_ROBOT) {
xmedia_svp_yolov5_attr yolov5_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov5_attr);
yolov5_attr.detect_threshold = 0.1f;
yolov5_attr.classifier_threshold = 0.5f;
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.stillness_thres = 0.95f;
yolov5_attr.movement_fps_thres = 7;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov5_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_RCNN_720P ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_CAR_RCNN_720P ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PET_RCNN_720P) {
xmedia_svp_yolov5_attr yolov5_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov5_attr);
yolov5_attr.detect_threshold = 0.3f;
yolov5_attr.classifier_threshold = 0.5f;
yolov5_attr.iou_threshold = 0.45f;
yolov5_attr.max_target_num = 10;
yolov5_attr.bytetrack_enable = XMEDIA_FALSE;
yolov5_attr.motionless_filter_enable = XMEDIA_FALSE;
yolov5_attr.stillness_thres = 0.95f;
yolov5_attr.movement_fps_thres = 7;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov5_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_MULTI_DETECT) {
xmedia_svp_multi_detect_attr multi_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &multi_attr);
multi_attr.car_attr.detect_threshold = 0.65f;
multi_attr.car_attr.iou_threshold = 0.45f;
multi_attr.car_attr.max_target_num = 10;
multi_attr.car_attr.classifier_threshold = 0.01f;
multi_attr.person_attr.detect_threshold = 0.65f;
multi_attr.person_attr.iou_threshold = 0.45f;
multi_attr.person_attr.max_target_num = 10;
multi_attr.person_attr.classifier_threshold = 0.01f;
multi_attr.pet_attr.detect_threshold = 0.65f;
multi_attr.pet_attr.iou_threshold = 0.45f;
multi_attr.pet_attr.max_target_num = 10;
multi_attr.pet_attr.classifier_threshold = 0.01f;
multi_attr.bytetrack_enable = XMEDIA_TRUE;
multi_attr.motionless_filter_enable = XMEDIA_FALSE;
multi_attr.stillness_thres = 0.95f;
multi_attr.movement_fps_thres = 7;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &multi_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_DMS) {
xmedia_svp_dms_attr dms_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &dms_attr);
dms_attr.detect_attr.detect_threshold = 0.5f;
dms_attr.detect_attr.iou_threshold = 0.5f;
dms_attr.detect_attr.max_target_num = 5;
dms_attr.detect_attr.classifier_threshold = 0.01f;
dms_attr.warn_frame = 10;
dms_attr.iou_thres = 0.1f;
dms_attr.detect_attr.bytetrack_enable = XMEDIA_TRUE;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &dms_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION) {
xmedia_svp_plate_reco_attr plate_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &plate_attr);
plate_attr.plate_detect_attr.detect_threshold = 0.65f;
plate_attr.plate_detect_attr.iou_threshold = 0.5f;
plate_attr.plate_detect_attr.max_target_num = 5;
plate_attr.plate_detect_attr.classifier_threshold = 0.01;
plate_attr.plate_detect_attr.bytetrack_enable = XMEDIA_TRUE;
plate_attr.plate_min_width = 85;
plate_attr.report_count = 15;
plate_attr.report_thres = 0.90;
plate_attr.detect_zone.zone_num = 1;
plate_attr.detect_zone.zones[0].points_count = 4;
plate_attr.detect_zone.zones[0].points_array[0].x = 0;
plate_attr.detect_zone.zones[0].points_array[0].y = 0;
plate_attr.detect_zone.zones[0].points_array[1].x = 1920 * SVP_SCALE_RATIO / SVP_BIG_STREAM_W;
plate_attr.detect_zone.zones[0].points_array[1].y = 0 * SVP_SCALE_RATIO / SVP_BIG_STREAM_H;
plate_attr.detect_zone.zones[0].points_array[2].x = 1920 * SVP_SCALE_RATIO / SVP_BIG_STREAM_W;
plate_attr.detect_zone.zones[0].points_array[2].y = 1080 * SVP_SCALE_RATIO / SVP_BIG_STREAM_H;
plate_attr.detect_zone.zones[0].points_array[3].x = 0 * SVP_SCALE_RATIO / SVP_BIG_STREAM_W;
plate_attr.detect_zone.zones[0].points_array[3].y = 1080 * SVP_SCALE_RATIO / SVP_BIG_STREAM_H;
xmedia_svp_task_set_attr(svp_info->svp_handle, &plate_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION) {
xmedia_svp_vehicle_reco_attr veh_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &veh_attr);
veh_attr.detect_attr.detect_threshold = 0.65f;
veh_attr.detect_attr.iou_threshold = 0.45f;
veh_attr.detect_attr.max_target_num = 5;
veh_attr.detect_attr.classifier_threshold = 0.01;
veh_attr.detect_attr.bytetrack_enable = XMEDIA_TRUE;
veh_attr.report_count = 8;
veh_attr.report_thres = 0.60;
xmedia_svp_task_set_attr(svp_info->svp_handle, &veh_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO) {
xmedia_svp_plate_vehicle_attr pv_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &pv_attr);
pv_attr.plate_attr.detect_threshold = 0.65f;
pv_attr.plate_attr.iou_threshold = 0.5f;
pv_attr.plate_attr.max_target_num = 5;
pv_attr.plate_attr.classifier_threshold = 0.01;
pv_attr.plate_attr.bytetrack_enable = XMEDIA_TRUE;
pv_attr.veh_attr.detect_threshold = 0.65f;
pv_attr.veh_attr.iou_threshold = 0.45f;
pv_attr.veh_attr.max_target_num = 5;
pv_attr.veh_attr.classifier_threshold = 0.01;
pv_attr.veh_attr.bytetrack_enable = XMEDIA_TRUE;
pv_attr.plate_min_width = 85;
pv_attr.report_count = 8;
pv_attr.report_thres = 0.60;
xmedia_svp_task_set_attr(svp_info->svp_handle, &pv_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_CAR ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PET_V8) {
xmedia_svp_yolov8_attr yolov8_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov8_attr);
yolov8_attr.detect_threshold = 0.5f;
yolov8_attr.classifier_threshold = 0.01f;
yolov8_attr.iou_threshold = 0.45f;
yolov8_attr.max_target_num = 10;
yolov8_attr.bytetrack_enable = XMEDIA_FALSE;
yolov8_attr.motionless_filter_enable = XMEDIA_FALSE;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov8_attr);
} else if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_CAR_NMV_FIRE) {
xmedia_svp_pcnmv_fire_attr multi_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &multi_attr);
multi_attr.detect_attr.detect_threshold = 0.4f;
multi_attr.detect_attr.iou_threshold = 0.45f;
multi_attr.detect_attr.max_target_num = 10;
multi_attr.detect_attr.classifier_threshold = 0.01f;
multi_attr.bytetrack_enable = XMEDIA_FALSE;
multi_attr.motionless_filter_enable = XMEDIA_FALSE;
multi_attr.stillness_thres = 0.95f;
multi_attr.movement_fps_thres = 7;
multi_attr.fire_change_rate = 0.3;
multi_attr.fire_loss_count = 5;
multi_attr.fire_ratio_sum = 1;
multi_attr.smoke_change_rate = 0.3;
multi_attr.smoke_loss_count = 5;
multi_attr.smoke_apear_count = 15;
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &multi_attr);
} else {
xmedia_svp_yolov5_attr yolov5_attr;
xmedia_svp_task_get_attr(svp_info->svp_handle, &yolov5_attr);
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.stillness_thres = 0.95f;
// 当前帧与历史帧相交大于95%算当前帧静止，静止计数+1，阈值越低越容易被判断为静止
yolov5_attr.movement_fps_thres = 7;
// 静止帧计数连续7帧大于stillness_thres，则目标被判断为静止，判断帧数越低越容易被判断为静止
if (svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_PERSON ||
svp_info->detect_type == SAMPLE_SVP_ALG_TYPE_FACE) {
yolov5_attr.smart_ae_enable = XMEDIA_TRUE;
yolov5_attr.smart_venc_enable = XMEDIA_TRUE;
yolov5_attr.smart_ae_array[0] = XMEDIA_TRUE;
yolov5_attr.smart_venc_array[0] = XMEDIA_TRUE;
}
ret = xmedia_svp_task_set_attr(svp_info->svp_handle, &yolov5_attr);
}
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_svp_task_create error ret : %d\n", ret);
xmedia_svp_task_destroy(svp_info->svp_handle);
sample_svp_free_reusemem();
xmedia_svp_uninit();
return XMEDIA_FAILURE;
}
g_svp_start_flag = XMEDIA_TRUE;
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
pthread_attr_setstacksize(&attr, 1024 * 1024 * 2); // 设置2M栈空间大小
pthread_create(&g_svp_thread, &attr, sample_svp_proc, svp_info);
pthread_setname_np(g_svp_thread, "svp_pthread_t");
return XMEDIA_SUCCESS;
}
xmedia_s32 sample_svp_sys_init(sample_sys_config *sys_config)
{
xmedia_s32 ret = 0;
ret = sample_comm_sys_init(sys_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_sys_init failed!\n");
return ret;
}
ret = sample_comm_vgs_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vgs_init failed!\n");
return ret;
}
// in online-online mode,vi and vpss must be reset at the same time
ret = sample_comm_vi_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vi_init failed!\n");
return ret;
}
ret = sample_comm_vpss_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vpss_init failed!\n");
return ret;
}
ret = sample_comm_vo_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vo_init failed!\n");
return ret;
}
ret = sample_comm_venc_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_venc_init failed!\n");
return ret;
}
return XMEDIA_SUCCESS;
}
xmedia_void sample_svp_sys_exit(void)
{
sample_comm_venc_stop_get_stream();
sample_comm_venc_exit();
sample_comm_vo_exit();
sample_comm_vpss_exit();
sample_comm_vi_exit();
sample_comm_vgs_exit();
sample_comm_sys_exit();
}
xmedia_void sample_svp_handle_sig(xmedia_s32 signo)
{
if (SIGINT == signo || SIGTSTP == signo || SIGTERM == signo) {
g_force_exit = XMEDIA_TRUE;
}
}
xmedia_s32 sample_svp_vi_online_vpss_online(sample_svp_alg_type detect_type)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
xmedia_s32 blk_size = 0;
xmedia_video_size pic_size = { 0 };
xmedia_video_size sub_pic_size = { 0 };
xmedia_video_size alg_big_pic_size = { 0 };
sample_comm_video_param video_param = { 0 };
sample_sys_config sys_config = { 0 };
sample_svp_info svp_info;
xmedia_s32 vi_dev = 0;
xmedia_s32 vi_pipe = 0;
xmedia_s32 vi_chn = 0;
sample_vi_config vi_config = { 0 };
xmedia_s32 sensor_type = sample_svp_sensor_type[0];
xmedia_u32 framerate = 0;
vi_sensor_info sensor_info = { 0 };
sample_isp_param isp_param = { 0 };
xmedia_isp_config isp_config = { 0 };
xmedia_bool mirror = XMEDIA_FALSE;
xmedia_bool flip = XMEDIA_FALSE;
xmedia_s32 vpss_chnl = 0;
xmedia_s32 vpss_pipe = 0;
xmedia_s32 vpss_ochn[3] = { 0, 1, 2};
sample_vpss_config vpss_config = { 0 };
xmedia_video_size vpss_ochn_size[VPSS_MAX_OCHN_NUM] = { 0 };
xmedia_s32 venc_chnl = 0;
xmedia_s32 venc_chn[3] = { 0, 1, 2};
xmedia_s32 venc_chn_cnt;
sample_venc_config venc_config = { 0 };
xmedia_s32 vo_dev = 0;
xmedia_s32 vo_layer = vo_dev;
xmedia_s32 vo_chn[1] = { 0 };
xmedia_s32 vo_chn_num = 1;
sample_vo_config_input vo_input = { 0 };
sample_vo_config vo_config = { 0 };
vo_input.square_sort = 1;
vo_input.screen_type = sample_vo_screen_type[0];
video_param.video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
video_param.pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
video_param.data_width = XMEDIA_VIDEO_DATA_WIDTH_8;
video_param.compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
sample_comm_vi_get_sensor_info(sensor_type, &sensor_info);
sample_comm_vi_get_framerate_by_sensor(sensor_type, &framerate);
// 这些类别需要1080p码流
if (detect_type == SAMPLE_SVP_ALG_TYPE_ADAS ||
detect_type == SAMPLE_SVP_ALG_TYPE_GESTURE_RECOGNITION ||
detect_type == SAMPLE_SVP_ALG_TYPE_FACE_EMOTION ||
detect_type == SAMPLE_SVP_ALG_TYPE_FACE_RECOGNITION ||
detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_RECOGNITION ||
detect_type == SAMPLE_SVP_ALG_TYPE_VEHICLE_RECOGNITION ||
detect_type == SAMPLE_SVP_ALG_TYPE_PLATE_VEHICLE_RECO) {
venc_chn_cnt = 3;
svp_info.big_stream = XMEDIA_TRUE;
} else {
venc_chn_cnt = 2;
svp_info.big_stream = XMEDIA_FALSE;
}
// sys init
sys_config.sys_conf.pipe_mode[0].vicap_viproc_mode = XMEDIA_WORK_MODE_ONLINE;
sys_config.sys_conf.pipe_mode[0].viproc_vpss_mode = XMEDIA_WORK_MODE_ONLINE;
sys_config.sys_conf.pipe_mode[0].gdc_vpss_mode = XMEDIA_WORK_MODE_OFFLINE;
sys_config.vb_conf.max_pool_cnt = 20;
pic_size.width = sensor_info.width;
pic_size.height = sensor_info.height;
blk_size = sample_comm_sys_get_buffer_size(pic_size, video_param.video_fmt, video_param.pixel_fmt,
video_param.data_width, video_param.compress_mode);
sys_config.vb_conf.common_pool[1].block_size = blk_size;
sys_config.vb_conf.common_pool[1].block_cnt = 4;
// 这些类别是720P模型，不需要360P码流
if (detect_type == SAMPLE_SVP_ALG_TYPE_PERSON_RCNN_720P ||
detect_type == SAMPLE_SVP_ALG_TYPE_CAR_RCNN_720P ||
detect_type == SAMPLE_SVP_ALG_TYPE_PET_RCNN_720P) {
sub_pic_size.width = SVP_MID_STREAM_W;
sub_pic_size.height = SVP_MID_STREAM_H;
} else {
sub_pic_size.width = SVP_SMALL_STREAM_W;
sub_pic_size.height = SVP_SMALL_STREAM_H;
}
blk_size = sample_comm_sys_get_buffer_size(sub_pic_size, video_param.video_fmt, video_param.pixel_fmt,
video_param.data_width, video_param.compress_mode);
sys_config.vb_conf.common_pool[2].block_size = blk_size;
sys_config.vb_conf.common_pool[2].block_cnt = 3;
if (svp_info.big_stream == XMEDIA_TRUE) {
alg_big_pic_size.width = SVP_BIG_STREAM_W;
alg_big_pic_size.height = SVP_BIG_STREAM_H;
blk_size = sample_comm_sys_get_buffer_size(alg_big_pic_size, video_param.video_fmt, video_param.pixel_fmt,
video_param.data_width, video_param.compress_mode);
sys_config.vb_conf.common_pool[3].block_size = blk_size;
sys_config.vb_conf.common_pool[3].block_cnt = 3;
}
sys_config.vb_conf.supplement_config = 1;
ret = sample_svp_sys_init(&sys_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sys init failed !\n");
return ret;
}
vi_config.dev_info[vi_dev].dev_en = XMEDIA_TRUE;
vi_config.dev_info[vi_dev].dev_no = vi_dev;
vi_config.dev_info[vi_dev].sensor_type = sensor_type;
vi_config.pipe_info[vi_pipe].pipe_en = XMEDIA_TRUE;
vi_config.pipe_info[vi_pipe].pipe_no = vi_pipe;
vi_config.pipe_info[vi_pipe].chn_info[vi_chn].chn_en = XMEDIA_TRUE;
vi_config.pipe_info[vi_pipe].chn_info[vi_chn].chn_no = vi_chn;
vi_config.dev_bind_pipe[vi_dev].pipe[0] = vi_pipe;
vi_config.dev_bind_pipe[vi_dev].pipe[1] = -1;
isp_config.fps = framerate;
isp_config.mode_config.work_mode = XMEDIA_ISP_WORK_MODE_MASTER;
isp_config.mode_config.master_mode.blend_stat_enable = XMEDIA_FALSE;
isp_config.mode_config.master_mode.slave_num = 0;
isp_config.pixel_fmt = sensor_info.pixel_format;
isp_config.size.height = sensor_info.height;
isp_config.size.width = sensor_info.width;
isp_config.wdr_mode = sensor_info.wdr_mode;
// isp pipe init
isp_param.pipe[vi_pipe] = vi_pipe;
isp_param.isp_info[vi_pipe].isp_pipe_en = XMEDIA_TRUE;
isp_param.isp_info[vi_pipe].isp_sensor_en = XMEDIA_TRUE;
isp_param.isp_info[vi_pipe].sensor_type = sensor_type;
isp_param.isp_info[vi_pipe].mirror = mirror;
isp_param.isp_info[vi_pipe].flip = flip;
memcpy(&(isp_param.isp_info[vi_pipe].isp_config), &isp_config, sizeof(xmedia_isp_config));
// isp init
ret = sample_comm_isp_init(&isp_param, &vi_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp init failed!\n");
goto exit0;
}
// vi start
ret = sample_comm_vi_start(&vi_config, &video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("start vi failed!\n");
goto exit1;
}
// isp start
ret = sample_comm_isp_start(&isp_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("start isp failed!\n");
goto exit2;
}
// vpss config
ret = sample_comm_vpss_get_default_pipe_cfg(&vpss_config.pipe_info[vpss_pipe].pipe_config, pic_size, &video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
goto exit2;
}
vpss_ochn_size[0].width = sensor_info.width;
vpss_ochn_size[0].height = sensor_info.height;
vpss_ochn_size[1].width = sub_pic_size.width;
vpss_ochn_size[1].height = sub_pic_size.height;
if (svp_info.big_stream == XMEDIA_TRUE) {
vpss_ochn_size[2].width = SVP_BIG_STREAM_W;
vpss_ochn_size[2].height = SVP_BIG_STREAM_H;
}
vpss_config.pipe_info[vpss_pipe].pipe_en = XMEDIA_TRUE;
vpss_config.pipe_info[vpss_pipe].pipe_no = vpss_pipe;
vpss_chnl = vpss_ochn[0];
vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_en = XMEDIA_TRUE;
vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_no = vpss_ochn[0];
ret = sample_comm_vpss_get_default_ochn_cfg(&vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config,
vpss_ochn_size[vpss_chnl], &video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
goto exit2;
}
vpss_chnl = vpss_ochn[1];
vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_en = XMEDIA_TRUE;
vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_no = vpss_ochn[1];
ret = sample_comm_vpss_get_default_ochn_cfg(&vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config,
vpss_ochn_size[vpss_chnl], &video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
goto exit2;
}
if (svp_info.big_stream == XMEDIA_TRUE) {
vpss_chnl = vpss_ochn[2];
vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_en = XMEDIA_TRUE;
vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_no = vpss_ochn[2];
ret = sample_comm_vpss_get_default_ochn_cfg(&vpss_config.pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config,
vpss_ochn_size[vpss_chnl], &video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
goto exit2;
}
}
// vpss start
ret = sample_comm_vpss_start(&vpss_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vpss start failed !\n");
goto exit2;
}
if (g_venc_use == XMEDIA_TRUE) {
// venc init
app_liveserver_init();
app_liveserver_start(vpss_ochn_size, venc_chn_cnt, framerate);
venc_chnl = venc_chn[0];
venc_config.chn_info[venc_chnl].venc_en = XMEDIA_TRUE;
venc_config.chn_info[venc_chnl].venc_chn = venc_chnl;
venc_config.chn_info[venc_chnl].payload_type = PT_H265;
venc_config.chn_info[venc_chnl].rc_mode = VENC_RC_MODE_H265CBR;
sample_comm_venc_get_default_chn_info(vpss_ochn_size[0], framerate, &venc_config.chn_info[venc_chnl]);
venc_config.chn_info[venc_chnl].rcn_ref_share_buf = XMEDIA_TRUE;
venc_chnl = venc_chn[1];
venc_config.chn_info[venc_chnl].venc_en = XMEDIA_TRUE;
venc_config.chn_info[venc_chnl].venc_chn = venc_chnl;
venc_config.chn_info[venc_chnl].payload_type = PT_H265;
venc_config.chn_info[venc_chnl].rc_mode = VENC_RC_MODE_H265CBR;
sample_comm_venc_get_default_chn_info(vpss_ochn_size[1], framerate, &venc_config.chn_info[venc_chnl]);
venc_config.chn_info[venc_chnl].rcn_ref_share_buf = XMEDIA_TRUE;
if (svp_info.big_stream == XMEDIA_TRUE) {
venc_chnl = venc_chn[2];
venc_config.chn_info[venc_chnl].venc_en = XMEDIA_TRUE;
venc_config.chn_info[venc_chnl].venc_chn = venc_chnl;
venc_config.chn_info[venc_chnl].payload_type = PT_H265;
venc_config.chn_info[venc_chnl].rc_mode = VENC_RC_MODE_H265CBR;
sample_comm_venc_get_default_chn_info(vpss_ochn_size[2], framerate, &venc_config.chn_info[venc_chnl]);
venc_config.chn_info[venc_chnl].rcn_ref_share_buf = XMEDIA_TRUE;
}
ret = sample_comm_venc_start(&venc_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("venc start failed !\n");
goto exit3;
}
ret = sample_comm_sys_vpss_bind_venc(vpss_pipe, vpss_ochn[0], venc_chn[0]);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vpss bind venc failed !\n");
goto exit4;
}
ret = sample_comm_venc_start_get_stream(venc_chn, venc_chn_cnt, XMEDIA_FALSE, XMEDIA_FALSE, "./output");
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("venc start get stream failed !\n");
goto exit5;
}
} else {
// vo init
ret = sample_comm_vo_get_default_config(vo_input, &vo_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get vo default config failed !\n");
goto exit3;
}
ret = sample_comm_vo_start(vo_dev, vo_layer, vo_chn, vo_chn_num, XMEDIA_TRUE, &vo_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vo start failed !\n");
goto exit3;
}
ret = sample_comm_sys_vpss_bind_vo(vpss_pipe, vpss_ochn[0], vo_layer, vo_chn[0]);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vpss bind vo failed !\n");
goto exit4;
}
}
svp_info.vpss_ochn[0] = vpss_ochn[0];
svp_info.vpss_ochn[1] = vpss_ochn[1];
svp_info.vpss_ochn[2] = vpss_ochn[2];
svp_info.venc_chn[0] = venc_chn[0];
svp_info.venc_chn[1] = venc_chn[1];
svp_info.venc_chn[2] = venc_chn[2];
svp_info.vpss_pipe = vpss_pipe;
//svp_info.venc_chnl = 1;
svp_info.detect_type = detect_type;
svp_info.svp_handle = -1;
ret = xmedia_vgs_init();
if(ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_vgs_init failed !\n");
goto exit5;
}
ret = sample_svp_start(&svp_info);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("svp start failed !\n");
goto exit6;
}
PAUSE(g_force_exit);
sample_svp_stop(&svp_info);
exit6:
if (g_venc_use == XMEDIA_TRUE) {
sample_comm_venc_stop_get_stream();
app_liveserver_stop();
app_liveserver_deinit();
}
xmedia_vgs_exit();
exit5:
if (g_venc_use == XMEDIA_TRUE) {
sample_comm_sys_vpss_unbind_venc(vpss_pipe, vpss_ochn[0], venc_chn[0]);
} else {
sample_comm_sys_vpss_unbind_vo(vpss_pipe, vpss_ochn[0], vo_layer, vo_chn[0]);
}
exit4:
if (g_venc_use == XMEDIA_TRUE) {
sample_comm_venc_stop(&venc_config);
} else {
sample_comm_vo_stop(vo_dev, vo_layer, vo_chn, vo_chn_num);
}
exit3:
sample_comm_vpss_stop(&vpss_config);
exit2:
sample_comm_isp_stop(&isp_param);
exit1:
sample_comm_vi_stop(&vi_config);
exit0:
sample_comm_isp_exit(&isp_param);
sample_svp_sys_exit();
return ret;
}
void sample_svp_usage(char* prg_name)
{
printf("Usage : %s <index> \n", prg_name);
printf("index:\n");
printf("\t 0) person detect \n");
printf("\t 1) person keypoint detect \n");
printf("\t 2) face detect \n");
printf("\t 3) pet detect \n");
printf("\t 4) car detect \n");
printf("\t 5) non motorized vehicle detect \n");
printf("\t 6) head detect \n");
printf("\t 7) fireworks detect \n");
printf("\t 8) package detect \n");
printf("\t 9) aov person \n");
printf("\t 10) adas detect \n");
printf("\t 11) fire detect \n");
printf("\t 12) gesture recognition \n");
printf("\t 13) face emotion classification \n");
printf("\t 14) face recognition \n");
printf("\t 15) person rcnn detect \n");
printf("\t 16) car rcnn detect \n");
printf("\t 17) pet rcnn detect \n");
printf("\t 18) companion robot \n");
printf("\t 19) person rcnn 720p detect \n");
printf("\t 20) car rcnn 720p detect \n");
printf("\t 21) pet rcnn 720p detect \n");
printf("\t 22) multi detect \n");
printf("\t 23) person and car detect \n");
printf("\t 24) dms detect \n");
printf("\t 25) plate reco detect \n");
printf("\t 26) vehicle reco detect \n");
printf("\t 27) plate vehicle reco detect \n");
printf("\t 28) pet detect yolov8 \n");
printf("\t 29) pcnmv fire detect \n");
return;
}
int main(int argc, char **argv)
{
xmedia_s32 ret = XMEDIA_SUCCESS;
sample_svp_alg_type type = 0;
#ifdef USE_OSD
// font init
ret = canvas_font_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("svp canvas_font_init failed !\n");
return 0;
}
#endif
signal(SIGINT, sample_svp_handle_sig);
signal(SIGTERM, sample_svp_handle_sig);
if (argc != 2) {
sample_svp_usage(argv[0]);
return 0;
}
type = atoi(argv[1]);
ret = sample_svp_vi_online_vpss_online(type);
if (XMEDIA_SUCCESS == ret) {
SAMPLE_PRT("program exit normally!\n");
} else {
SAMPLE_PRT("program exit abnormally!\n");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink