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

905 lines
32 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) XMEDIA. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include "sample_comm.h"
#include "sample_comm_sys.h"
#include "sample_comm_vgs.h"
#include "sample_comm_vi.h"
#include "sample_comm_isp.h"
#include "sample_comm_vpss.h"
#include "sample_comm_venc.h"
#include "sample_comm_livestream.h"
#include "sample_comm_vo.h"
#include "sample_comm_pq_bin.h"
typedef struct {
xmedia_bool is_compress;
// sensor
xmedia_s32 sensor_type;
xmedia_u32 framerate;
vi_sensor_info sensor_info;
// isp
sample_isp_param isp_param;
xmedia_isp_config isp_config;
// vi
xmedia_s32 vi_dev[2]; // 两路
xmedia_s32 vi_pipe[2]; // 两路
xmedia_s32 vi_chn[2]; // 两路
sample_vi_config vi_config;
sample_comm_video_param video_param;
// vpss
xmedia_s32 vpss_pipe[2]; // 两路
xmedia_s32 vpss_chnl;
xmedia_s32 vpss_ichn;
xmedia_s32 vpss_ochn[2];
xmedia_video_size pic_size;
sample_vpss_config vpss_config;
xmedia_video_size vpss_ochn_size[VPSS_MAX_OCHN_NUM];
xmedia_u32 wrap_buffer_line;
// venc
xmedia_s32 venc_chnl;
xmedia_s32 venc_chn[4];
xmedia_s32 venc_chn_cnt;
sample_venc_config venc_config;
xmedia_u32 ainr_route_num; // 1或2
xmedia_sys_switch_config switch_config;
} sample_ainr_param;
static xmedia_bool g_ainr_force_exit = XMEDIA_FALSE;
static xmedia_void sample_ainr_usage(xmedia_char *args)
{
printf("\n"
"***************************************************************\n"
"Usage: %s [scene_mode]\n"
"scene_mode: \n"
" 0: 单路线性ainr 15fps\n"
" 1: 双路线性ainr 7fps (switch)\n"
" 2: 双路线性ainr 7fps\n"
" 3: 双路线性ainr 7fps (外置switch)\n"
"stream_mode: VENC output \n"
"e.g: ./sample_vio 0\n"
"***************************************************************\n"
"\n",
args);
return;
}
xmedia_void sample_ainr_handle_sig(xmedia_s32 signo)
{
if (SIGINT == signo || SIGTSTP == signo || SIGTERM == signo) {
g_ainr_force_exit = XMEDIA_TRUE;
}
}
static xmedia_s32 sample_ainr_other_mod_init(xmedia_void)
{
xmedia_s32 ret;
ret = sample_comm_vgs_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vgs_init failed!\n");
return ret;
}
ret = sample_comm_vi_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vi_init failed!\n");
sample_comm_vgs_exit();
return ret;
}
ret = sample_comm_vpss_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vpss_init failed!\n");
sample_comm_vgs_exit();
sample_comm_vi_exit();
return ret;
}
ret = sample_comm_vo_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vo_init failed!\n");
sample_comm_vgs_exit();
sample_comm_vi_exit();
sample_comm_vpss_exit();
return ret;
}
ret = sample_comm_venc_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_venc_init failed!\n");
sample_comm_vgs_exit();
sample_comm_vi_exit();
sample_comm_vpss_exit();
sample_comm_vo_exit();
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_ainr_vb_pool_init(sample_ainr_param *ai_param, sample_sys_config *sys_config,
xmedia_u32 ainr_route_num)
{
xmedia_vb_base_info vb_base_info = { 0 };
xmedia_vb_cal_cfg vb_cfg = { 0 };
xmedia_u32 pool_index = ((ainr_route_num == 1) ? 0 : 4);
xmedia_s32 blk_size = 0;
xmedia_video_size pic_size = { 0 };
// vicap 输出(npu输入)
vb_base_info.width = ai_param->sensor_info.width;
vb_base_info.height = ai_param->sensor_info.height;
vb_base_info.video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
vb_base_info.pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_RAW;
if (ainr_route_num == 1) {
vb_base_info.bit_width = ai_param->sensor_info.bit_width;
} else if (ainr_route_num == 2) {
vb_base_info.bit_width = ai_param->sensor_info.bit_width;
}
SAMPLE_PRT("PIPE %d bit_width : %d \n", ainr_route_num - 1, vb_base_info.bit_width);
vb_base_info.align = DEFAULT_ALIGN;
vb_base_info.cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
vb_base_info.ainr_attr.ainr_en = XMEDIA_TRUE;
vb_base_info.ainr_attr.ainr_direction = XMEDIA_VB_AINR_DIRECTION_INPUT;
xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
sys_config->vb_conf.common_pool[pool_index].block_size = vb_cfg.vb_size;
sys_config->vb_conf.common_pool[pool_index].block_cnt = 2;
SAMPLE_PRT("PIPE %d : vi-npu 2VB, size : %d \n", ainr_route_num - 1, vb_cfg.vb_size);
// npu 输出
vb_base_info.ainr_attr.ainr_direction = XMEDIA_VB_AINR_DIRECTION_OUTPUT;
vb_base_info.cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
xmedia_vb_get_buffer_config(&vb_base_info, &vb_cfg);
sys_config->vb_conf.common_pool[pool_index + 1].block_size = vb_cfg.vb_size;
sys_config->vb_conf.common_pool[pool_index + 1].block_cnt = (ai_param->switch_config.multi_pipe_mode == XMEDIA_SYS_MULTI_PIPE_MODE_DUAL_SWITCH ? 1 : 1);
SAMPLE_PRT("PIPE %d : npu output %dVB, size : %d \n", ainr_route_num - 1, sys_config->vb_conf.common_pool[pool_index + 1].block_cnt, vb_cfg.vb_size);
// vpss 输出
pic_size.width = ai_param->sensor_info.width;
pic_size.height = ai_param->sensor_info.height;
blk_size = sample_comm_sys_get_wrap_buffer_size(pic_size, XMEDIA_VIDEO_FMT_TILE_32x4, XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
XMEDIA_VIDEO_DATA_WIDTH_8, XMEDIA_VIDEO_COMPRESS_MODE_TILE_COMPACT, &ai_param->wrap_buffer_line);
sys_config->vb_conf.common_pool[pool_index + 2].block_size = blk_size;
sys_config->vb_conf.common_pool[pool_index + 2].block_cnt = (ai_param->switch_config.multi_pipe_mode == XMEDIA_SYS_MULTI_PIPE_MODE_DUAL_SWITCH ? 2 : 1);
SAMPLE_PRT("PIPE %d : vpss-venc %dVB, size : %d \n", ainr_route_num - 1, sys_config->vb_conf.common_pool[pool_index + 2].block_cnt, blk_size);
pic_size.width = 640;
pic_size.height = 480;
blk_size = sample_comm_sys_get_buffer_size(pic_size, XMEDIA_VIDEO_FMT_LINEAR, XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420,
XMEDIA_VIDEO_DATA_WIDTH_8, XMEDIA_VIDEO_COMPRESS_MODE_NONE);
sys_config->vb_conf.common_pool[pool_index + 3].block_size = blk_size;
sys_config->vb_conf.common_pool[pool_index + 3].block_cnt = 2;
}
static xmedia_s32 sample_ainr_sys_prepare(sample_ainr_param *ai_param)
{
xmedia_s32 ret;
sample_sys_config sys_config = { 0 };
xmedia_u32 i;
// 系统模式，固定全离线
for (i = 0; i < VI_MAX_PIPE_NUM; i++) {
sys_config.sys_conf.pipe_mode[i].vicap_viproc_mode = XMEDIA_WORK_MODE_OFFLINE;
sys_config.sys_conf.pipe_mode[i].viproc_vpss_mode = XMEDIA_WORK_MODE_ONLINE;
sys_config.sys_conf.pipe_mode[i].gdc_vpss_mode = XMEDIA_WORK_MODE_OFFLINE;
}
sys_config.compress_level = XMEDIA_SYS_COMPRESS_LEVEL_0;
ret = sample_comm_sys_cmp_init(&sys_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("common sys failed !\n");
return ret;
}
// vb 池子
sys_config.vb_conf.max_pool_cnt = 30;
sample_ainr_vb_pool_init(ai_param, &sys_config, 1);
if (ai_param->ainr_route_num == 2) {
if(ai_param->switch_config.multi_pipe_mode == XMEDIA_SYS_MULTI_PIPE_MODE_NORMAL) {
sample_ainr_vb_pool_init(ai_param, &sys_config, 2);
}
}
sys_config.vb_conf.supplement_config = 1;
ret = sample_comm_vb_init(&sys_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_comm_vb_init failed!\n");
return ret;
}
if (ai_param->ainr_route_num == 2 && ai_param->switch_config.multi_pipe_mode == XMEDIA_SYS_MULTI_PIPE_MODE_DUAL_SWITCH) {
// 双路开switch
ret = xmedia_sys_set_switch_config(0, &ai_param->switch_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("xmedia_sys_set_switch_config failed!\n");
sample_comm_sys_exit();
return ret;
}
}
ret = sample_ainr_other_mod_init();
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("sample_ainr_other_mod_init failed!\n");
sample_comm_sys_exit();
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_ainr_sys_unprepare()
{
sample_comm_vgs_exit();
sample_comm_vi_exit();
sample_comm_vpss_exit();
sample_comm_vo_exit();
sample_comm_venc_exit();
sample_comm_sys_exit();
}
static xmedia_s32 sample_ainr_isp_prepare(sample_ainr_param *ai_param)
{
xmedia_s32 ret;
sample_comm_npu_workspace_info work_space_info = {0};
xmedia_s32 index = 0;
index = sample_comm_isp_get_sensor_effect_index(g_ainr_model_list, AINR_LIST_NUM, ai_param->isp_param.isp_info[0].sensor_type);
if(index == XMEDIA_FAILURE) {
SAMPLE_PRT("get ainr model failed!\n");
return XMEDIA_FAILURE;
}
ret = sample_comm_isp_init(&ai_param->isp_param, &ai_param->vi_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp init failed!\n");
return ret;
}
work_space_info.npu_modle_num = 1;
work_space_info.npu_model_path[0] = g_ainr_model_list[index].load_file;
ret = sample_comm_sys_npu_acquire_workspace(&work_space_info);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("acquire workspace fail\n");
return ret;
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_ainr_isp_unprepare(sample_ainr_param *ai_param)
{
sample_comm_isp_ainr_exit(&ai_param->isp_param);
sample_comm_sys_npu_release_workspace();
sample_comm_isp_exit(&ai_param->isp_param);
}
static xmedia_s32 sample_ainr_other_mod_run(sample_ainr_param *ai_param)
{
xmedia_s32 ret;
sample_vpss_config *vpss_config = &ai_param->vpss_config;
xmedia_s32 vpss_pipe;
xmedia_s32 vpss_chnl;
xmedia_video_size pic_size = { 0 };
xmedia_u32 i;
pic_size.width = ai_param->sensor_info.width;
pic_size.height = ai_param->sensor_info.height;
// vpss config
for (i = 0; i < ai_param->ainr_route_num; i++) {
vpss_pipe = ai_param->vpss_pipe[i];
ret = sample_comm_vpss_get_default_pipe_cfg(&vpss_config->pipe_info[vpss_pipe].pipe_config, pic_size,
&ai_param->video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
return ret;
}
ai_param->vpss_ochn_size[0].width = ai_param->sensor_info.width;
ai_param->vpss_ochn_size[0].height = ai_param->sensor_info.height;
ai_param->vpss_ochn_size[1].width = 640;
ai_param->vpss_ochn_size[1].height = 480;
vpss_config->pipe_info[vpss_pipe].pipe_en = XMEDIA_TRUE;
vpss_config->pipe_info[vpss_pipe].pipe_no = vpss_pipe;
vpss_chnl = ai_param->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 = ai_param->vpss_ochn[0];
vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].wrap_attr.buf_line = ai_param->wrap_buffer_line;
vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].wrap_attr.enable = XMEDIA_TRUE;
ret = sample_comm_vpss_get_default_ochn_cfg(&vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config,
ai_param->vpss_ochn_size[vpss_chnl], &ai_param->video_param);
vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config.cmp_mode = XMEDIA_VIDEO_COMPRESS_MODE_TILE_COMPACT;
vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config.video_fmt = XMEDIA_VIDEO_FMT_TILE_32x4;
vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config.depth = 0;
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
return ret;
}
vpss_chnl = ai_param->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 = ai_param->vpss_ochn[1];
ret = sample_comm_vpss_get_default_ochn_cfg(&vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config,
ai_param->vpss_ochn_size[vpss_chnl], &ai_param->video_param);
vpss_config->pipe_info[vpss_pipe].chn_info[vpss_chnl].chn_config.depth = 0;
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("get default pipe cfg failed !\n");
return ret;
}
}
// vpss start
ret = sample_comm_vpss_start(vpss_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vpss start failed !\n");
return ret;
}
for (i = 0; i < ai_param->ainr_route_num; i++) {
ret = sample_comm_sys_vi_bind_vpss(ai_param->vi_pipe[i], ai_param->vi_chn[i], ai_param->vpss_pipe[i],
ai_param->vpss_ichn);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vi bind vpss failed !\n");
for (; i > 0; ) {
i = i - 1;
sample_comm_sys_vi_unbind_vpss(ai_param->vi_pipe[i], ai_param->vi_chn[i], ai_param->vpss_pipe[i],
ai_param->vpss_ichn);
}
goto FAIL0;
}
}
// venc init
app_liveserver_init();
app_liveserver_start(ai_param->vpss_ochn_size, ai_param->venc_chn_cnt, ai_param->framerate);
for (i = 0; i < ai_param->ainr_route_num; i++) {
ai_param->venc_chnl = ai_param->venc_chn[i * 2];
ai_param->venc_config.chn_info[ai_param->venc_chnl].venc_en = XMEDIA_TRUE;
ai_param->venc_config.chn_info[ai_param->venc_chnl].venc_chn = ai_param->venc_chnl;
ai_param->venc_config.chn_info[ai_param->venc_chnl].payload_type = PT_H265;
ai_param->venc_config.chn_info[ai_param->venc_chnl].rc_mode = VENC_RC_MODE_H265CBR;
sample_comm_venc_get_default_chn_info(ai_param->vpss_ochn_size[0], ai_param->framerate,
&ai_param->venc_config.chn_info[ai_param->venc_chnl]);
ai_param->venc_config.chn_info[ai_param->venc_chnl].rcn_ref_share_buf = XMEDIA_TRUE;
ai_param->venc_chnl = ai_param->venc_chn[i * 2 + 1];
ai_param->venc_config.chn_info[ai_param->venc_chnl].venc_en = XMEDIA_TRUE;
ai_param->venc_config.chn_info[ai_param->venc_chnl].venc_chn = ai_param->venc_chnl;
ai_param->venc_config.chn_info[ai_param->venc_chnl].payload_type = PT_H265;
ai_param->venc_config.chn_info[ai_param->venc_chnl].rc_mode = VENC_RC_MODE_H265CBR;
sample_comm_venc_get_default_chn_info(ai_param->vpss_ochn_size[1], ai_param->framerate,
&ai_param->venc_config.chn_info[ai_param->venc_chnl]);
ai_param->venc_config.chn_info[ai_param->venc_chnl].rcn_ref_share_buf = XMEDIA_TRUE;
}
ret = sample_comm_venc_start(&ai_param->venc_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("venc start failed !\n");
goto FAIL1;
}
for (i = 0; i < ai_param->ainr_route_num; i++) {
xmedia_venc_chn_param chn_param;
xmedia_venc_get_chn_param(ai_param->venc_chn[2 * i], &chn_param);
chn_param.priority = 1;
xmedia_venc_set_chn_param(ai_param->venc_chn[2 * i], &chn_param);
ret = sample_comm_sys_vpss_bind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[0],
ai_param->venc_chn[i * 2]);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vpss bind venc failed !\n");
for (; i > 0; ) {
i = i - 1;
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[0], ai_param->venc_chn[i * 2]);
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[1], ai_param->venc_chn[i * 2 + 1]);
}
goto FAIL2;
}
ret = sample_comm_sys_vpss_bind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[1],
ai_param->venc_chn[i * 2 + 1]);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("vpss bind venc failed !\n");
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[0], ai_param->venc_chn[i * 2]);
for (; i > 0; i--) {
i = i - 1;
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[0], ai_param->venc_chn[i * 2]);
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[1], ai_param->venc_chn[i * 2 + 1]);
}
goto FAIL2;
}
}
ret = sample_comm_venc_start_get_stream(ai_param->venc_chn, ai_param->venc_chn_cnt, XMEDIA_FALSE,
XMEDIA_FALSE, ".");
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("venc start get stream failed !\n");
goto FAIL3;
}
return XMEDIA_SUCCESS;
FAIL3:
for (i = 0; i < ai_param->ainr_route_num; i++) {
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[0], ai_param->venc_chn[i * 2]);
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[1], ai_param->venc_chn[i * 2 + 1]);
}
FAIL2:
sample_comm_venc_stop(&ai_param->venc_config);
FAIL1:
for (i = 0; i < ai_param->ainr_route_num; i++) {
sample_comm_sys_vi_unbind_vpss(ai_param->vi_pipe[i], ai_param->vi_chn[i], ai_param->vpss_pipe[i],
ai_param->vpss_ichn);
}
FAIL0:
sample_comm_vpss_stop(vpss_config);
return ret;
}
static xmedia_s32 sample_ainr_process_run(sample_ainr_param *ai_param)
{
xmedia_s32 ret;
bin_module_info pq_info = {0};
xmedia_s32 id = -1;
pq_info.vi.enable = XMEDIA_TRUE;
pq_info.mcf.enable = XMEDIA_FALSE;
pq_info.vpss.enable = XMEDIA_FALSE;
ret = sample_comm_vi_start(&ai_param->vi_config, &ai_param->video_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("start vi failed!\n");
return ret;
}
ret = sample_comm_isp_ainr_init(&ai_param->isp_param, &ai_param->vi_config);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp ainr init failed!\n");
return ret;
}
ret = sample_comm_isp_start(&ai_param->isp_param);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("start isp failed!\n");
sample_comm_vi_stop(&ai_param->vi_config);
return ret;
}
ret = sample_ainr_other_mod_run(ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_comm_isp_stop(&ai_param->isp_param);
sample_comm_vi_stop(&ai_param->vi_config);
return ret;
}
id = sample_comm_isp_get_sensor_effect_index(g_ainr_pqbin_list, AINR_LIST_NUM, ai_param->isp_param.isp_info[0].sensor_type);
if (id == XMEDIA_FAILURE) {
SAMPLE_ERR("Can not found sensor0 pq.bin\n");
} else {
pq_info.vi.pipe = 0;
ret = sample_comm_pq_bin_import(&pq_info, g_ainr_pqbin_list[id].load_file);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp load pq bin failed!\n");
}
}
ret = sample_comm_isp_enable_fpn(ai_param->vi_pipe[0], XMEDIA_NULL);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp enable fpn failed!\n");
}
if(ai_param->ainr_route_num == 2) {
id = sample_comm_isp_get_sensor_effect_index(g_ainr_pqbin_list, AINR_LIST_NUM, ai_param->isp_param.isp_info[1].sensor_type);
if (id == XMEDIA_FAILURE) {
SAMPLE_ERR("Can not found sensor1 pq.bin\n");
} else {
pq_info.vi.pipe = 1;
ret = sample_comm_pq_bin_import(&pq_info, g_ainr_pqbin_list[id].load_file);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp1 load pq bin failed!\n");
}
}
ret = sample_comm_isp_enable_fpn(ai_param->vi_pipe[1], XMEDIA_NULL);
if (ret != XMEDIA_SUCCESS) {
SAMPLE_PRT("isp1 enable fpn failed!\n");
}
}
return XMEDIA_SUCCESS;
}
static xmedia_void sample_ainr_process_exit(sample_ainr_param *ai_param)
{
xmedia_u32 i;
PAUSE(g_ainr_force_exit);
sample_comm_venc_stop_get_stream();
app_liveserver_stop();
app_liveserver_deinit();
for (i = 0; i < ai_param->ainr_route_num; i++) {
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[1], ai_param->venc_chn[i * 2 + 1]);
sample_comm_sys_vpss_unbind_venc(ai_param->vpss_pipe[i], ai_param->vpss_ochn[0], ai_param->venc_chn[i * 2]);
}
sample_comm_venc_stop(&ai_param->venc_config);
sample_comm_venc_exit();
for (i = 0; i < ai_param->ainr_route_num; i++) {
sample_comm_sys_vi_unbind_vpss(ai_param->vi_pipe[i], ai_param->vi_chn[i], ai_param->vpss_pipe[i],
ai_param->vpss_ichn);
}
sample_comm_vpss_stop(&ai_param->vpss_config);
sample_comm_vpss_exit();
sample_comm_isp_stop(&ai_param->isp_param);
sample_comm_vi_stop(&ai_param->vi_config);
sample_comm_isp_disable_fpn(ai_param->vi_pipe[0]);
if(ai_param->ainr_route_num == 2) {
sample_comm_isp_disable_fpn(ai_param->vi_pipe[1]);
}
sample_comm_isp_ainr_exit(&ai_param->isp_param);
sample_comm_sys_npu_release_workspace();
sample_comm_isp_exit(&ai_param->isp_param);
sample_comm_vi_exit();
sample_comm_vgs_exit();
sample_comm_sys_exit();
}
static xmedia_void sample_ainr_single_linear_init(sample_ainr_param *ai_param, xmedia_u32 index)
{
xmedia_s32 vi_dev = ai_param->vi_dev[index];
xmedia_s32 vi_pipe = ai_param->vi_pipe[index];
xmedia_s32 vi_chn = ai_param->vi_chn[index];
// 从sensor获取分辨率
sample_comm_vi_get_sensor_info(ai_param->sensor_type, &ai_param->sensor_info);
sample_comm_vi_get_framerate_by_sensor(ai_param->sensor_type, &ai_param->framerate);
ai_param->isp_param.pipe[vi_pipe] = vi_pipe;
ai_param->isp_param.isp_info[vi_pipe].isp_pipe_en = XMEDIA_TRUE;
ai_param->isp_param.isp_info[vi_pipe].isp_sensor_en = XMEDIA_TRUE;
ai_param->isp_param.isp_info[vi_pipe].sensor_type = ai_param->sensor_type;
ai_param->isp_param.isp_info[vi_pipe].mirror = XMEDIA_FALSE;
ai_param->isp_param.isp_info[vi_pipe].flip = XMEDIA_FALSE;
ai_param->isp_param.isp_info[vi_pipe].disable_dynamic_fps = XMEDIA_TRUE;
ai_param->isp_config.mode_config.work_mode = XMEDIA_ISP_WORK_MODE_MASTER;
ai_param->isp_config.mode_config.master_mode.blend_stat_enable = XMEDIA_FALSE;
ai_param->isp_config.mode_config.master_mode.slave_num = 0;
ai_param->isp_config.pixel_fmt = ai_param->sensor_info.pixel_format;
ai_param->isp_config.size.height = ai_param->sensor_info.height;
ai_param->isp_config.size.width = ai_param->sensor_info.width;
ai_param->isp_config.wdr_mode = ai_param->sensor_info.wdr_mode;
memcpy(&(ai_param->isp_param.isp_info[vi_pipe].isp_config), &ai_param->isp_config, sizeof(xmedia_isp_config));
ai_param->vi_config.dev_info[vi_dev].dev_en = XMEDIA_TRUE;
ai_param->vi_config.dev_info[vi_dev].dev_no = vi_dev;
ai_param->vi_config.dev_info[vi_dev].sensor_type = ai_param->sensor_type;
ai_param->vi_config.pipe_info[vi_pipe].pipe_en = XMEDIA_TRUE;
ai_param->vi_config.pipe_info[vi_pipe].pipe_no = vi_pipe;
ai_param->vi_config.pipe_info[vi_pipe].chn_info[vi_chn].chn_en = XMEDIA_TRUE;
ai_param->vi_config.pipe_info[vi_pipe].chn_info[vi_chn].chn_no = vi_chn;
ai_param->vi_config.dev_bind_pipe[vi_dev].pipe[0] = vi_pipe;
ai_param->vi_config.dev_bind_pipe[vi_dev].pipe[1] = -1;
ai_param->vi_config.pipe_info[vi_pipe].pipe_config.compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
ai_param->vi_config.pipe_info[vi_pipe].ainr_en = XMEDIA_TRUE;
ai_param->vi_config.pipe_info[vi_pipe].ainr_model_bitwidth = ai_param->sensor_info.bit_width;
// 如果使用双联sensor模组,自行修改i2c地址并使能dev_i2c_en
ai_param->vi_config.dev_info[vi_dev].dev_i2c_en = XMEDIA_FALSE;
if (ai_param->sensor_type == OMNIVISION_OS08A20_MIPI_4M_30FPS_10BIT ||
ai_param->sensor_type == OMNIVISION_OS08A20_MIPI_8M_20FPS_10BIT) {
// demo 08a20双联模组的i2c地址。
ai_param->vi_config.dev_info[vi_dev].dev_i2c_addr = vi_dev == 2 ? 0x6c : 0x20;
}
// vpss/venc/vo
ai_param->video_param.video_fmt = XMEDIA_VIDEO_FMT_LINEAR;
ai_param->video_param.pixel_fmt = XMEDIA_VIDEO_PIXEL_FMT_YVU_SEMIPLANAR_420;
ai_param->video_param.data_width = XMEDIA_VIDEO_DATA_WIDTH_8;
ai_param->video_param.compress_mode = XMEDIA_VIDEO_COMPRESS_MODE_NONE;
ai_param->vpss_chnl = 0;
ai_param->vpss_ichn = 0;
ai_param->vpss_ochn[0] = 0;
ai_param->vpss_ochn[1] = 1;
ai_param->venc_chnl = 0;
if (index == 0) {
ai_param->venc_chn[0] = 0;
ai_param->venc_chn[1] = 1;
ai_param->venc_chn_cnt = 2;
} else {
ai_param->venc_chn[2] = 2;
ai_param->venc_chn[3] = 3;
ai_param->venc_chn_cnt = 4;
}
return;
}
static xmedia_void sample_ainr_double_linear_init(sample_ainr_param *ai_param)
{
sample_ainr_single_linear_init(ai_param, 0);
sample_ainr_single_linear_init(ai_param, 1);
return;
}
static xmedia_s32 sample_ainr_single_linear(xmedia_void)
{
xmedia_s32 ret;
sample_ainr_param ai_param = {0};
ai_param.sensor_type = SENSOR0_TYPE;
ai_param.is_compress = XMEDIA_FALSE;
ai_param.ainr_route_num = 1;
ai_param.vi_dev[0] = 0;
ai_param.vi_pipe[0] = 0;
ai_param.vi_chn[0] = 0;
ai_param.vpss_pipe[0] = 0;
ai_param.isp_config.fps = 15;
sample_ainr_single_linear_init(&ai_param, 0);
ret = sample_ainr_sys_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
ret = sample_ainr_isp_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_sys_unprepare();
return ret;
}
ret = sample_ainr_process_run(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_isp_unprepare(&ai_param);
sample_ainr_sys_unprepare();
return ret;
}
sample_ainr_process_exit(&ai_param);
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_ainr_double_linear_switch(xmedia_void)
{
xmedia_s32 ret;
sample_ainr_param ai_param = {0};
ai_param.sensor_type = SENSOR0_TYPE;
ai_param.is_compress = XMEDIA_FALSE;
ai_param.ainr_route_num = 2;
ai_param.vi_dev[0] = 0;
ai_param.vi_pipe[0] = 0;
ai_param.vi_chn[0] = 0;
ai_param.vpss_pipe[0] = 0;
ai_param.vi_dev[1] = 1;
ai_param.vi_pipe[1] = 1;
ai_param.vi_chn[1] = 0;
ai_param.vpss_pipe[1] = 1;
ai_param.isp_config.fps = 7;
sample_ainr_double_linear_init(&ai_param);
// switch init
ai_param.switch_config.ext_switch_en = XMEDIA_FALSE;
ai_param.switch_config.master_pipe_id = 0;
ai_param.switch_config.multi_pipe_mode = XMEDIA_SYS_MULTI_PIPE_MODE_DUAL_SWITCH;
ai_param.switch_config.pipe_id[0] = 0;
ai_param.switch_config.pipe_id[1] = 1;
ai_param.switch_config.pipe_num = 2;
ai_param.switch_config.pipe_sel[0] = 0;
ai_param.switch_config.pipe_sel[1] = 1;
ai_param.switch_config.sync_mode = XMEDIA_SYS_SWITCH_SYNC_MODE_SOC_MASTER_SLAVE;
ai_param.isp_param.isp_info[0].sns_work_mode = XMEDIA_SENSOR_WORK_MODE_NORMAL;
ai_param.isp_param.isp_info[1].sns_work_mode = XMEDIA_SENSOR_WORK_MODE_SLAVE;
ai_param.isp_param.isp_info[0].disable_dynamic_fps = XMEDIA_TRUE;
ai_param.isp_param.isp_info[1].disable_dynamic_fps = XMEDIA_TRUE;
ret = sample_ainr_sys_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
ret = sample_ainr_isp_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_sys_unprepare();
return ret;
}
ret = sample_ainr_process_run(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_isp_unprepare(&ai_param);
sample_ainr_sys_unprepare();
return ret;
}
sample_ainr_process_exit(&ai_param);
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_ainr_double_linear(xmedia_void)
{
xmedia_s32 ret;
sample_ainr_param ai_param = {0};
ai_param.sensor_type = SENSOR0_TYPE;
ai_param.is_compress = XMEDIA_FALSE;
ai_param.ainr_route_num = 2;
ai_param.vi_dev[0] = 0;
ai_param.vi_pipe[0] = 0;
ai_param.vi_chn[0] = 0;
ai_param.vpss_pipe[0] = 0;
ai_param.vi_dev[1] = 1;
ai_param.vi_pipe[1] = 1;
ai_param.vi_chn[1] = 0;
ai_param.vpss_pipe[1] = 1;
ai_param.isp_config.fps = 7;
sample_ainr_double_linear_init(&ai_param);
ai_param.isp_param.isp_info[0].disable_dynamic_fps = XMEDIA_TRUE;
ai_param.isp_param.isp_info[1].disable_dynamic_fps = XMEDIA_TRUE;
ret = sample_ainr_sys_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
ret = sample_ainr_isp_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_sys_unprepare();
return ret;
}
ret = sample_ainr_process_run(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_isp_unprepare(&ai_param);
sample_ainr_sys_unprepare();
return ret;
}
sample_ainr_process_exit(&ai_param);
return XMEDIA_SUCCESS;
}
static xmedia_s32 sample_ainr_double_linear_ext_switch(xmedia_void)
{
xmedia_s32 ret;
sample_ainr_param ai_param = {0};
ai_param.sensor_type = SENSOR0_TYPE;
ai_param.is_compress = XMEDIA_FALSE;
ai_param.ainr_route_num = 2;
ai_param.vi_dev[0] = 0;
ai_param.vi_pipe[0] = 0;
ai_param.vi_chn[0] = 0;
ai_param.vpss_pipe[0] = 0;
ai_param.vi_dev[1] = 0;
ai_param.vi_pipe[1] = 1;
ai_param.vi_chn[1] = 0;
ai_param.vpss_pipe[1] = 1;
ai_param.isp_config.fps = 7;
sample_ainr_double_linear_init(&ai_param);
// 外置switch,绑定关系特殊处理
ai_param.vi_config.dev_bind_pipe[0].pipe[0] = 0;
ai_param.vi_config.dev_bind_pipe[0].pipe[1] = 1;
// ext switch init
ai_param.switch_config.ext_switch_en = XMEDIA_TRUE;
ai_param.switch_config.master_pipe_id = 0;
ai_param.switch_config.multi_pipe_mode = XMEDIA_SYS_MULTI_PIPE_MODE_DUAL_SWITCH;
ai_param.switch_config.pipe_id[0] = 0;
ai_param.switch_config.pipe_id[1] = 1;
ai_param.switch_config.pipe_num = 2;
ai_param.switch_config.pipe_sel[0] = 0;
ai_param.switch_config.pipe_sel[1] = 1;
ai_param.switch_config.sync_mode = XMEDIA_SYS_SWITCH_SYNC_MODE_SOC_MASTER_SLAVE;
ai_param.isp_param.isp_info[0].sns_work_mode = XMEDIA_SENSOR_WORK_MODE_NORMAL;
ai_param.isp_param.isp_info[1].sns_work_mode = XMEDIA_SENSOR_WORK_MODE_SLAVE;
ai_param.isp_param.isp_info[0].disable_dynamic_fps = XMEDIA_TRUE;
ai_param.isp_param.isp_info[1].disable_dynamic_fps = XMEDIA_TRUE;
ai_param.isp_param.isp_info[1].serdes_enable = XMEDIA_TRUE;
ai_param.isp_param.isp_info[1].i2c_addr_en = XMEDIA_TRUE;
ai_param.isp_param.isp_info[1].i2c_addr = 0X62;
ret = sample_ainr_sys_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
return ret;
}
ret = sample_ainr_isp_prepare(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_sys_unprepare();
return ret;
}
ret = sample_ainr_process_run(&ai_param);
if (ret != XMEDIA_SUCCESS) {
sample_ainr_isp_unprepare(&ai_param);
sample_ainr_sys_unprepare();
return ret;
}
sample_ainr_process_exit(&ai_param);
return XMEDIA_SUCCESS;
}
int main(int argc, char **argv)
{
xmedia_s32 scene_mode = 0;
xmedia_s32 ret;
signal(SIGINT, sample_ainr_handle_sig);
signal(SIGTERM, sample_ainr_handle_sig);
if (argc == 2) {
if (!strncmp(argv[1], "-h", 2)) {
sample_ainr_usage(argv[0]);
return 0;
}
} else {
sample_ainr_usage(argv[0]);
return 0;
}
scene_mode = atoi(argv[1]);
switch (scene_mode) {
case 0:
ret = sample_ainr_single_linear();
break;
case 1:
ret = sample_ainr_double_linear_switch();
break;
case 2:
ret = sample_ainr_double_linear();
break;
case 3:
ret = sample_ainr_double_linear_ext_switch();
break;
default:
sample_ainr_usage(argv[0]);
return 0;
}
if (ret == XMEDIA_SUCCESS) {
SAMPLE_PRT("program exit normally!\n");
} else {
SAMPLE_PRT("program exit abnormally!\n");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink