3516cv610在sample_aiisp上多创一路编码流，方法

3516cv610在sample_aiisp上多创一路编码流，方法

首先确保 vpss grp0有视频流

最好保证 已经有一路视频流能推出来

多创一路编码流思路为
将 vpss grp0又绑定给 vpss_chn1

vpss_chn1有绑定给 venc_chn1

这样我们就多创了一路视频流。

这里思路完全正确 可以实现

整个工程代码，在底部链接获取

aiisp需要对 sc500ai寄存器进行操作

// 改变 sc500ai的bayer格式
// 改变为 RGGB的格式
3211， 0x05
3213,  0x05

sdk说明

sdk_010打AOV的补丁

硬件

cv610_20s+sc500ai

下面是 aiisp的例子，多创建一路编码流

// sample_aiisp.c#include <signal.h>
#include "sample_comm.h"
#include "sample_ipc.h"
#include "sample_aibnr.h"#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <poll.h>
#include <sys/time.h>
#include <sys/select.h>
#include <fcntl.h>
#include <errno.h>
#include <pthread.h>
#include <math.h>
#include <unistd.h>
#include <signal.h>
#include <sys/prctl.h>
#include <limits.h>#include "rtsp_demo.h"rtsp_demo_handle g_rtsplive = NULL;
rtsp_session_handle session= NULL;static td_void sample_aiisp_usage(const char *prg_name)
{printf("usage : %s <index> \n", prg_name);printf("index:\n");printf("    (0) aibnr line mode : base mode, has reference frame\n");printf("    (1) aibnr line pro mode\n");
}static td_void sample_register_sig_handler(td_void (*sig_handle)(td_s32))
{struct sigaction sa;(td_void)memset_s(&sa, sizeof(struct sigaction), 0, sizeof(struct sigaction));sa.sa_handler = sig_handle;sa.sa_flags = 0;sigaction(SIGINT, &sa, TD_NULL);sigaction(SIGTERM, &sa, TD_NULL);
}static td_s32 sample_aiisp_msg_proc_vb_pool_share(td_s32 pid)
{td_s32 ret;td_u32 i;td_bool isp_states[OT_VI_MAX_PIPE_NUM];
#ifndef SAMPLE_MEM_SHARE_ENABLEot_vb_common_pools_id pools_id = {0};if (ss_mpi_vb_get_common_pool_id(&pools_id) != TD_SUCCESS) {sample_print("get common pool_id failed!\n");return TD_FAILURE;}for (i = 0; i < pools_id.pool_cnt; ++i) {if (ss_mpi_vb_pool_share(pools_id.pool[i], pid) != TD_SUCCESS) {sample_print("vb pool share failed!\n");return TD_FAILURE;}}
#endifret = sample_comm_vi_get_isp_run_state(isp_states, OT_VI_MAX_PIPE_NUM);if (ret != TD_SUCCESS) {sample_print("get isp states fail\n");return TD_FAILURE;}for (i = 0; i < OT_VI_MAX_PIPE_NUM; i++) {if (!isp_states[i]) {continue;}ret = ss_mpi_isp_mem_share(i, pid);if (ret != TD_SUCCESS) {sample_print("ss_mpi_isp_mem_share vi_pipe %u, pid %d fail\n", i, pid);}}return TD_SUCCESS;
}static td_void sample_aiisp_msg_proc_vb_pool_unshare(td_s32 pid)
{td_s32 ret;td_u32 i;td_bool isp_states[OT_VI_MAX_PIPE_NUM];
#ifndef SAMPLE_MEM_SHARE_ENABLEot_vb_common_pools_id pools_id = {0};if (ss_mpi_vb_get_common_pool_id(&pools_id) == TD_SUCCESS) {for (i = 0; i < pools_id.pool_cnt; ++i) {ret = ss_mpi_vb_pool_unshare(pools_id.pool[i], pid);if (ret != TD_SUCCESS) {sample_print("ss_mpi_vb_pool_unshare vi_pipe %u, pid %d fail\n", pools_id.pool[i], pid);}}}
#endifret = sample_comm_vi_get_isp_run_state(isp_states, OT_VI_MAX_PIPE_NUM);if (ret != TD_SUCCESS) {sample_print("get isp states fail\n");return;}for (i = 0; i < OT_VI_MAX_PIPE_NUM; i++) {if (!isp_states[i]) {continue;}ret = ss_mpi_isp_mem_unshare(i, pid);if (ret != TD_SUCCESS) {sample_print("ss_mpi_isp_mem_unshare vi_pipe %u, pid %d fail\n", i, pid);}}
}static td_s32 sample_aiisp_ipc_msg_proc(const sample_ipc_msg_req_buf *msg_req_buf,td_bool *is_need_fb, sample_ipc_msg_res_buf *msg_res_buf)
{td_s32 ret;if (msg_req_buf == TD_NULL || is_need_fb == TD_NULL) {return TD_FAILURE;}/* need feedback default */*is_need_fb = TD_TRUE;switch ((sample_msg_type)msg_req_buf->msg_type) {case SAMPLE_MSG_TYPE_VB_POOL_SHARE_REQ: {if (msg_res_buf == TD_NULL) {return TD_FAILURE;}ret = sample_aiisp_msg_proc_vb_pool_share(msg_req_buf->msg_data.pid);msg_res_buf->msg_type = SAMPLE_MSG_TYPE_VB_POOL_SHARE_RES;msg_res_buf->msg_data.is_req_success = (ret == TD_SUCCESS) ? TD_TRUE : TD_FALSE;break;}case SAMPLE_MSG_TYPE_VB_POOL_UNSHARE_REQ: {if (msg_res_buf == TD_NULL) {return TD_FAILURE;}sample_aiisp_msg_proc_vb_pool_unshare(msg_req_buf->msg_data.pid);msg_res_buf->msg_type = SAMPLE_MSG_TYPE_VB_POOL_UNSHARE_RES;msg_res_buf->msg_data.is_req_success = TD_TRUE;break;}default: {printf("unsupported msg type(%ld)!\n", msg_req_buf->msg_type);return TD_FAILURE;}}return TD_SUCCESS;
}td_s32 sample_comm_save_frame_to_file(td_s32 index, sample_comm_venc_stream_proc_info *stream_proc_info,ot_venc_stream *stream, ot_venc_stream_buf_info *stream_buf_info, ot_payload_type *payload_type)
{
// printf("\n\nfunction: %s    line: %d\n\n", __FUNCTION__, __LINE__);td_s32 ret, fd;if (payload_type[index] == OT_PT_JPEG) {if (snprintf_s(stream_proc_info->file_name[index], FILE_NAME_LEN, FILE_NAME_LEN - 1, "./") < 0) {free(stream->pack);return SAMPLE_RETURN_NULL;}if (realpath(stream_proc_info->file_name[index], stream_proc_info->real_file_name[index]) == TD_NULL) {free(stream->pack);sample_print("chn[%d] stream file path error\n", stream_proc_info->venc_chn);return SAMPLE_RETURN_NULL;}if (snprintf_s(stream_proc_info->real_file_name[index], FILE_NAME_LEN, FILE_NAME_LEN - 1,"stream_chn%d_%u%s", index, stream_proc_info->picture_cnt[index], stream_proc_info->file_postfix) < 0) {free(stream->pack);return SAMPLE_RETURN_NULL;}stream_proc_info->file[index] = fopen(stream_proc_info->real_file_name[index], "wb");if (!stream_proc_info->file[index]) {free(stream->pack);sample_print("open file err!\n");return SAMPLE_RETURN_NULL;}fd = fileno(stream_proc_info->file[index]);fchmod(fd, S_IRUSR | S_IWUSR);}#ifndef __LITEOS__ot_unused(stream_buf_info);ret = sample_comm_venc_save_stream(stream_proc_info->file[index], stream);// printf("\nindex is %d\n", index);//rtsp发送td_u8 * pStremData = NULL;int nSize = 0;td_u32 j=0;if(index==1){//发送venc通道1for (j = 0; j < stream->pack_cnt; j++) {//(td_void)fwrite(stream->pack[j].addr + stream->pack[j].offset, stream->pack[j].len - stream->pack[j].offset, 1, fd);if(stream->pack[j].data_type.h264_type == OT_VENC_H264_NALU_SEI) continue;//暂时去掉SEI帧pStremData = stream->pack[j].addr + stream->pack[j].offset;nSize = stream->pack[j].len - stream->pack[j].offset;if(g_rtsplive){rtsp_sever_tx_video(g_rtsplive,session,pStremData,nSize,stream->pack[j].pts);}}}ret = TD_SUCCESS;#elseret = sample_comm_venc_save_stream_phys_addr(stream_proc_info->file[index], &stream_buf_info[index], stream);
#endifif (ret != TD_SUCCESS) {free(stream->pack);stream->pack = TD_NULL;sample_print("save stream failed!\n");return SAMPLE_RETURN_BREAK;}return TD_SUCCESS;
}td_s32 main(td_s32 argc, td_char *argv[])
{g_rtsplive = create_rtsp_demo(554);//554端口创建rtspserversession= create_rtsp_session(g_rtsplive,"/test.264");//创建rtsp会话 rtsp://[IP]/test.264td_s32 ret = TD_FAILURE;td_u32 index;td_char *para_stop;sample_aiisp_usage(argv[0]);sample_register_sig_handler(sample_aiisp_handle_sig);if (sample_ipc_server_init(sample_aiisp_ipc_msg_proc) != TD_SUCCESS) {printf("sample_ipc_server_init failed!!!\n");}sample_aibnr_param aibnr_param = {0};aibnr_param.is_wdr_mode = TD_FALSE;aibnr_param.ref_mode = OT_AIBNR_REF_MODE_NORM;aibnr_param.is_blend = TD_FALSE;aibnr_param.is_pro = TD_FALSE;ret = sample_aibnr(&aibnr_param);if ((ret == TD_SUCCESS) && (sample_aiisp_get_sig() == 0)) {sample_print("\033[0;32mprogram exit normally!\033[0;39m\n");} else {sample_print("\033[0;31mprogram exit abnormally!\033[0;39m\n");}server_deinit:sample_ipc_server_deinit();exit:
#ifdef __LITEOS__return ret;
#elseexit(ret);
#endif
}

主要在 sample_aibnr.c、sample_aiisp_common.c增加编码通道

// sample_aibnr.c#include "sample_aibnr.h"
#include "sample_aiisp_common.h"
#include "ss_mpi_aibnr.h"#define VB_AIBNR_LINE_CNT 4
#define VB_AIBNR_TNR_CNT 4
#define VB_AIBNR_COMMON_VB_CNT 3
// #define VB_AIBNR_COMMON_VB_CNT 1//----------------------------add a chnnel stream 开始
#define CHN_NUM_MAX 2typedef struct {td_s32 venc_chn_num;ot_size enc_size[CHN_NUM_MAX];td_s32 vpss_chn_depth;
} sample_venc_param;
//----------------------------add a chnnel stream 结束static td_u16 g_r_calib_lut[OT_AIBNR_NLC_LUT_NUM] = {1043, 1043, 1029, 1024, 1021, 1020, 1019, 1018, 1017, 1017, 1016,1015, 1014, 1014, 1013, 1013, 1012, 1012, 1012, 1011, 1011, 1011,1010, 1010, 1010, 1010, 1009, 1009, 1008, 1008, 1008, 1000
};static td_u16 g_b_calib_lut[OT_AIBNR_NLC_LUT_NUM] = {1024, 1024, 1027, 1028, 1029, 1029, 1029, 1029, 1027, 1024, 1021,1019, 1018, 1016, 1015, 1013, 1011, 1009, 1008, 1006, 1005, 1004,1004, 1004, 1003, 1003, 1003, 1002, 1002, 1002, 1002, 1000
};static td_s32 sample_aibnr_set_nlc(ot_aibnr_nlc *nlc)
{td_s32 ret;nlc->enable = TD_FALSE;nlc->step_bit = 0x3;ret = memcpy_s(nlc->r_fact, sizeof(nlc->r_fact), g_r_calib_lut, sizeof(g_r_calib_lut));if (ret != EOK) {printf("memcpy_s failed!\n");return TD_FAILURE;}ret = memcpy_s(nlc->b_fact, sizeof(nlc->b_fact), g_b_calib_lut, sizeof(g_b_calib_lut));if (ret != EOK) {printf("memcpy_s failed!\n");return TD_FAILURE;}return TD_SUCCESS;
}static td_s32 sample_aibnr_set_model_attr(td_void)
{td_s32 ret;ot_aibnr_model_list list = {0};ot_aibnr_model_attr model_attr = {0};ret = ss_mpi_aibnr_query_model_list(&list);if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_query_model_list error\n");return ret;}printf("model list info:\n");printf("num:%d\n", list.num);for (td_u32 i = 0; i < list.num && i < OT_AIISP_MAX_MODEL_NUM; i++) {printf("id:%d  is wdr:%d\n", list.info[i].id, list.info[i].is_wdr_mode);}//---------------------aibnr模型0// sample_get_char("select model 0");model_attr.op_type = OT_OP_MODE_MANUAL;model_attr.manual_id = 0;ss_mpi_aibnr_set_model_attr(0, &model_attr);//---------------------------aibnr模型1// sample_get_char("select model 1");// model_attr.op_type = OT_OP_MODE_MANUAL;// model_attr.manual_id = 1;// ss_mpi_aibnr_set_model_attr(0, &model_attr);//-------------------------模型auto mode// sample_get_char("set auto mode");// model_attr.op_type = OT_OP_MODE_AUTO;// for (td_u32 i = 0; i < OT_AIISP_AUTO_ISO_NUM; i++) {//     model_attr.auto_id[i] = 1;//     if (i < 0x2) {//         model_attr.auto_id[i] = 0;//     }// }// ss_mpi_aibnr_set_model_attr(0, &model_attr);return TD_SUCCESS;
}static td_s32 sample_aibnr_set_attr(ot_vi_pipe vi_pipe, sample_aibnr_param *aibnr_param)
{td_s32 ret;ot_aibnr_attr aibnr_attr;ret = ss_mpi_aibnr_get_attr(vi_pipe, &aibnr_attr);if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_get_attr error\n");return ret;}aibnr_attr.enable = TD_TRUE;aibnr_attr.bnr_bypass = TD_FALSE;aibnr_attr.blend = aibnr_param->is_blend;aibnr_attr.op_type = OT_OP_MODE_MANUAL;aibnr_attr.manual_attr.sfs = 31; /* sfs: 31 */ret = sample_aibnr_set_nlc(&aibnr_attr.manual_attr.nlc);if (ret != TD_SUCCESS) {printf("call sample_aibnr_set_nlc failed!\n");return TD_FAILURE;}ret = ss_mpi_aibnr_set_attr(vi_pipe, &aibnr_attr);if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_set_attr error\n");return ret;}if (aibnr_param->is_pro == TD_FALSE) {sample_aibnr_set_model_attr();}return TD_SUCCESS;
}// 有调用
static td_s32 sample_aibnr_load_model(ot_aibnr_model *model_info, td_s32 *model_id, td_char *model_file)
{td_s32 ret;ot_aiisp_model *model = &model_info->model;// printf("\n\nfunction: %s    line: %d\n\n", __FUNCTION__, __LINE__);if (model->mem_info.virt_addr == TD_NULL) {ret = sample_aiisp_load_mem((ot_aiisp_mem_info *)&(model->mem_info), model_file);if (ret != TD_SUCCESS) {sample_print("sample_aiisp_load_mem error\n");return ret;}}ret = ss_mpi_aibnr_load_model(model_info, model_id);if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_load_model error(%#x)\n", ret);goto unload_mem;}return ret;unload_mem:sample_aiisp_unload_mem((ot_aiisp_mem_info *)&(model->mem_info));return ret;
}static td_s32 sample_aibnr_unload_model(ot_aibnr_model *model, td_s32 model_id)
{td_s32 ret;ret = ss_mpi_aibnr_unload_model(model_id);if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_unload_cfg error(%#x)\n", ret);}sample_aiisp_unload_mem((ot_aiisp_mem_info *)&(model->model.mem_info));return ret;
}// 有调用
static td_s32 sample_aibnr_load(ot_size in_size, ot_aibnr_model *model_info, td_s32 *model_id,sample_aibnr_param *aibnr_param)
{
// printf("\n\nfunction: %s    line: %d\n\n", __FUNCTION__, __LINE__);
printf("\n\nwidth is %d     height is %d\n\n", in_size.width, in_size.height);td_s32 ret;td_u32 max_len = 256;td_char model_file[max_len];if (aibnr_param->is_pro == TD_FALSE) {
printf("\n\naiisp normal bin\n\n");ret = snprintf_s(model_file, max_len, max_len - 1, "./aibnr_model/aibnr_model_%dx%d.bin",in_size.width, in_size.height);} else {
printf("\n\naiisp pro bin\n\n");ret = snprintf_s(model_file, max_len, max_len - 1, "./aibnr_model/aibnr_model_%dx%d_pro.bin",in_size.width, in_size.height);}if (ret < 0) {printf("set name failed!\n");return ret;}model_info[0].model.preempted_en = TD_FALSE;model_info[0].model.image_size.width  = in_size.width;model_info[0].model.image_size.height = in_size.height;model_info[0].is_wdr_mode = aibnr_param->is_wdr_mode;model_info[0].ref_mode = aibnr_param->ref_mode;model_info[0].nlc_en = TD_FALSE;model_info[0].is_wdr_mode = TD_FALSE;ret = (&model_info[0], &model_id[0], model_file);   // 这里报错，确实是这里报错// if (ret != TD_SUCCESS) // {//     return ret;// }// 这里这个分支也会进if (aibnr_param->is_pro == TD_FALSE) {
// 进入这个分支
// printf("\n\nfunction: %s    line: %d\n\n", __FUNCTION__, __LINE__);// ret = snprintf_s(model_file, max_len, max_len - 1, "./aibnr_model/aibnr_model_%dx%d.bin", in_size.width, in_size.height);ret = snprintf_s(model_file, max_len, max_len - 1, "./aibnr_model/aibnr_model_%dx%d_high_iso.bin",in_size.width, in_size.height);if (ret < 0) {printf("set name failed!\n");goto unload;}model_info[1].model.preempted_en = TD_FALSE;model_info[1].model.image_size.width  = in_size.width;model_info[1].model.image_size.height = in_size.height;model_info[1].is_wdr_mode = aibnr_param->is_wdr_mode;model_info[1].ref_mode = aibnr_param->ref_mode;model_info[1].nlc_en = TD_FALSE;model_info[1].is_wdr_mode = TD_FALSE;ret = sample_aibnr_load_model(&model_info[1], &model_id[1], model_file);// if (ret != TD_SUCCESS)// {//     goto unload;// }}return TD_SUCCESS;unload:sample_aibnr_unload_model(&model_info[0], model_id[0]);return TD_FAILURE;
}static td_s32 sample_aibnr_start(ot_vi_pipe vi_pipe, ot_size in_size, ot_aibnr_model *model_info, td_s32 *model_id,td_s32 model_size, sample_aibnr_param *aibnr_param)
{td_s32 ret = ss_mpi_aibnr_init();ot_aibnr_cfg cfg;td_s32 i;if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_init error(%#x)\n", ret);return ret;}// 加载 aibnr模型文件ret = sample_aibnr_load(in_size, model_info, model_id, aibnr_param);if (ret != TD_SUCCESS) {sample_print("sample_aibnr_load error(%#x)\n", ret);goto deinit;}cfg.ref_mode = aibnr_param->ref_mode; /* ref mode NORM: need reference frame; NONE: no reference frame */ret = ss_mpi_aibnr_set_cfg(vi_pipe, &cfg);if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_set_alg_cfg error(%#x)\n", ret);goto unload_model;}usleep(100000);// int c;// printf("请输入一个字符：");// c = getchar();  // 读取用户输入的第一个字符// printf("你输入的字符是：%c\n", (char)c);// sample_get_char("enable");  // 只是获取输入的符号ret = ss_mpi_aibnr_enable(vi_pipe); // 底层接口if (ret != TD_SUCCESS) {sample_print("ss_mpi_aibnr_enable error(%#x)\n", ret);goto unload_model;}ret = sample_aibnr_set_attr(vi_pipe, aibnr_param);if (ret != TD_SUCCESS) {sample_print("sample_aibnr_set_attr error(%#x)\n", ret);goto aibnr_disable;}return ret;aibnr_disable:ss_mpi_aibnr_disable(vi_pipe);
unload_model:for (i = 0;i < model_size; i++) {if (model_id[i] != -1) {sample_aibnr_unload_model(&model_info[i], model_id[i]);}}deinit:ss_mpi_aibnr_exit();return ret;
}static td_s32 sample_aibnr_unload(ot_vi_pipe vi_pipe, ot_aibnr_model *model, td_s32 *model_id, td_s32 model_size)
{td_s32 return_value = TD_SUCCESS;td_s32 ret;td_s32 i;for (i = 0; i < model_size; i++) {if (model_id[i] != -1) {ret = sample_aibnr_unload_model(&model[i], model_id[i]);if (ret != TD_SUCCESS) {return_value = ret;}}}return return_value;
}static td_s32 sample_aibnr_stop(ot_vi_pipe vi_pipe, ot_aibnr_model *model, td_s32 *model_id, td_s32 model_size)
{td_s32 ret1;td_s32 ret2;ret1 = ss_mpi_aibnr_disable(vi_pipe);if (ret1 != TD_SUCCESS) {sample_print("ss_mpi_aibnr_disable false error(%#x)\n", ret1);}ret2 = sample_aibnr_unload(vi_pipe, model, model_id, model_size);if (ret2 != TD_SUCCESS) {sample_print("sample_aibnr_unload_exit false error(%#x)\n", ret2);}ss_mpi_aibnr_exit();if ((ret1 != TD_SUCCESS) || (ret2 != TD_SUCCESS)) {return TD_FAILURE;}return TD_SUCCESS;
}static td_void sample_aibnr_deinit_aiisp_pool(ot_vi_pipe vi_pipe, const sample_vi_cfg *vi_cfg)
{if (vi_cfg->pipe_info[vi_pipe].attach_pool != OT_VB_INVALID_POOL_ID) {ss_mpi_vb_destroy_pool(vi_cfg->pipe_info[vi_pipe].attach_pool);}
}static td_void sample_aibnr_stop_vi(ot_vi_pipe vi_pipe, const sample_vi_cfg *vi_cfg)
{sample_comm_vi_stop_vi(vi_cfg);sample_aibnr_deinit_aiisp_pool(vi_pipe, vi_cfg);sample_comm_sys_exit();
}static td_s32 sample_aibnr_init_aiisp_pool(ot_size *in_size, td_u32 vb_cnt)
{td_s32 blk_size;ot_vb_pool vb_pool;ot_vb_pool_cfg vb_pool_cfg = {0};blk_size = ot_aibnr_get_pic_buf_size(in_size->width, in_size->height);vb_pool_cfg.blk_size = blk_size;vb_pool_cfg.blk_cnt = vb_cnt;vb_pool_cfg.remap_mode = OT_VB_REMAP_MODE_NONE;vb_pool = ss_mpi_vb_create_pool(&vb_pool_cfg);if (vb_pool == OT_VB_INVALID_POOL_ID) {sample_print("aibnr create user pool failed!\n");return OT_VB_INVALID_POOL_ID;}#ifdef SAMPLE_MEM_SHARE_ENABLEss_mpi_vb_pool_share_all(vb_pool);
#endifreturn vb_pool;
}static td_void sample_aibnr_set_vpss_crop(ot_vpss_grp grp, ot_size *in_size)
{td_s32 ret;ot_vpss_crop_info crop_info = {0};td_u32 crop_pixel = 8;crop_info.enable = TD_TRUE;crop_info.crop_mode = OT_COORD_ABS;crop_info.crop_rect.x = crop_pixel;crop_info.crop_rect.y = crop_pixel;crop_info.crop_rect.width = in_size->width - crop_pixel;crop_info.crop_rect.height = in_size->height - crop_pixel;ret = ss_mpi_vpss_set_grp_crop(grp, &crop_info);if (ret != TD_SUCCESS) {sample_print("ss_mpi_vpss_set_grp_crop failed!\n");}
}static td_s32 sample_venc_get_enc_size(ot_pic_size *pic_size, sample_venc_param *enc_param)
{td_s32 i;td_s32 ret;for (i = 0; i < enc_param->venc_chn_num && i < CHN_NUM_MAX; i++) {ret = sample_comm_sys_get_pic_size(pic_size[i], &(enc_param->enc_size[i]));if (ret != TD_SUCCESS) {sample_print("sample_comm_sys_get_pic_size failed!\n");return ret;}}return TD_SUCCESS;
}static td_s32 sample_aibnr_start_vi(ot_vi_pipe vi_pipe, sample_vi_cfg *vi_cfg, ot_size *in_size,td_u32 vb_cnt)
{td_s32 ret;sample_vi_pipe_info *pipe_info = &vi_cfg->pipe_info[vi_pipe];if (sample_aiisp_sys_init(in_size, VB_AIBNR_COMMON_VB_CNT) != TD_SUCCESS) {sample_print("sample_aiisp_sys_init failed.\n");return TD_FAILURE;}/* aiisp route use attach pool */pipe_info->attach_pool = sample_aibnr_init_aiisp_pool(&pipe_info->pipe_attr.size, vb_cnt);if (pipe_info->attach_pool == OT_VB_INVALID_POOL_ID) {goto sys_exit;}ret = sample_comm_vi_start_vi(vi_cfg);if (ret != TD_SUCCESS) {sample_print("start vi failed.\n");goto denit_vb_pool;}return TD_SUCCESS;denit_vb_pool:ss_mpi_vb_destroy_pool(pipe_info->attach_pool);
sys_exit:sample_comm_sys_exit();return TD_FAILURE;
}static td_s32 sample_aibnr_set_blc(ot_vi_pipe vi_pipe, sample_sns_type sns_type)
{td_s32 i, j, ret;ot_isp_black_level_attr black_level_attr;ret = ss_mpi_isp_get_black_level_attr(vi_pipe, &black_level_attr);if (ret != TD_SUCCESS) {sample_print("ss_mpi_isp_get_black_level_attr failed.\n");return TD_FAILURE;}black_level_attr.user_black_level_en = TD_TRUE;for (i = 0; i < OT_ISP_WDR_MAX_FRAME_NUM; i++) {for (j = 0; j < OT_ISP_BAYER_CHN_NUM; j++) {black_level_attr.user_black_level[i][j] = 1200; /* user_black_level of aibnr default as 1200 */}}ret = ss_mpi_isp_set_black_level_attr(vi_pipe, &black_level_attr);if (ret != TD_SUCCESS) {sample_print("ss_mpi_isp_set_black_level_attr failed.\n");return TD_FAILURE;}return TD_SUCCESS;
}static td_void sample_aibnr_update_cfg(ot_vi_pipe vi_pipe, sample_vi_cfg *vi_cfg, td_bool is_pro)
{td_u32 dst_fps = (is_pro == TD_TRUE) ? 5 : 12;  /* 5\12fps */vi_cfg->pipe_info[vi_pipe].set_early_end_mode = TD_TRUE;vi_cfg->pipe_info[vi_pipe].pipe_attr.compress_mode = OT_COMPRESS_MODE_NONE;vi_cfg->pipe_info[vi_pipe].pipe_attr.pixel_format = OT_PIXEL_FORMAT_RGB_BAYER_12BPP; /* 12fps */vi_cfg->pipe_info[vi_pipe].isp_info.isp_pub_attr.frame_rate = dst_fps;
}static td_s32 sample_aibnr_check_support(ot_vi_pipe vi_pipe, sample_aibnr_param *aibnr_param)
{if (aibnr_param->is_wdr_mode == TD_TRUE) {if (aibnr_param->is_blend != TD_FALSE) {sample_print("normal_blend must be false in wdr mode\n");return TD_FAILURE;}if (vi_pipe >= OT_VI_MAX_PHYS_PIPE_NUM) {sample_print("vi_pipe must be phy pipe in wdr mode\n");return TD_FAILURE;}}/* bnr_bypass must be false when attr->enable is false *//* blend must be false when bnr_bypass is true *//* vi must be offline */return TD_SUCCESS;
}// 这里真正开始调 aiisp
td_s32 sample_aibnr(sample_aibnr_param *aibnr_param)
{td_s32 ret = TD_FAILURE;sample_vi_cfg vi_cfg = {0};sample_sns_type sns_type = SC500AI_MIPI_5M_30FPS_10BIT;// sample_sns_type sns_type = SENSOR0_TYPE;const td_u32 vb_cnt = (aibnr_param->is_pro == TD_TRUE) ? VB_AIBNR_TNR_CNT : VB_AIBNR_LINE_CNT;const ot_vi_pipe vi_pipe = aibnr_param->is_wdr_mode ? 1 : 0;ot_vi_pipe master_pipe = 0;const ot_vi_chn vi_chn = 0;ot_vpss_grp vpss_grp[1] = {0};ot_size in_size = {0};ot_aibnr_model model_info[2] = {0};td_s32 model_id[2] = {-1, -1};td_s32 model_size = (td_s32)(sizeof(model_id) / sizeof(td_s32));// ot_vpss_grp vpss_grp = 0;if (sample_aibnr_check_support(vi_pipe, aibnr_param) != TD_SUCCESS) {return TD_FAILURE;}sample_aiisp_get_default_cfg(sns_type, vi_pipe, &in_size, &vi_cfg);sample_aibnr_update_cfg(vi_pipe, &vi_cfg, aibnr_param->is_pro);// 开始 viif (sample_aibnr_start_vi(vi_pipe, &vi_cfg, &in_size, vb_cnt) != TD_SUCCESS) {return TD_FAILURE;}// sample_comm_vi_bind_vpss(master_pipe, 0, vpss_grp, 0); // sample_venc是这样写的，这样写会有报错 logsample_comm_vi_bind_vpss(master_pipe, vi_chn, vpss_grp[0], 0);if (sample_aiisp_start_vpss(vpss_grp[0], &in_size) != TD_SUCCESS)   // 这样使用不会报错。这里将 vi的流绑定给 vpss_grp[0]。确实只需将 vpss grp0的流绑定给 vpss_chn就好{goto stop_vi;}// sample_aibnr_set_vpss_crop(vpss_grp, &in_size);sample_aibnr_set_vpss_crop(vpss_grp[0], &in_size);  // 只对 vpss_grp[0]做裁剪printf("\n\nsizeof(vpss_grp) / sizeof(vpss_grp) is %d\n\n", sizeof(vpss_grp) / sizeof(vpss_grp));if (sample_aiisp_start_venc_bind(vpss_grp, sizeof(vpss_grp) / sizeof(vpss_grp), &in_size) != TD_SUCCESS) // // if (sample_aiisp_start_venc_bind(vpss_grp, 2, &in_size) != TD_SUCCESS)  // 这里涉及到创建 venc_chn// if (sample_aiisp_start_venc_bind(vpss_grp, sizeof(vpss_grp) / sizeof(vpss_grp[0]), &in_size) != TD_SUCCESS) // {goto stop_vpss;}// 通过 VI、VPSS模块获取原始视频帧；// 在 VENC中创建两个编码通道，绑定统一 VI、VPSS输入源// 分别配置两路通道的编码参数if (sample_aibnr_set_blc(master_pipe, sns_type) != TD_SUCCESS) {goto stop_venc_and_vo;}if (sample_aibnr_start(vi_pipe, in_size, model_info, model_id, model_size, aibnr_param) != TD_SUCCESS) {goto stop_venc_and_vo;}if (sample_aiisp_set_long_frame_mode(master_pipe, aibnr_param->is_wdr_mode) != TD_SUCCESS) {goto stop_aibnr;}sample_get_char("disable");ret = TD_SUCCESS;stop_aibnr:sample_aibnr_stop(vi_pipe, model_info, model_id, model_size);// sample_get_char("exit");usleep(100000);stop_venc_and_vo:// sample_aiisp_stop_venc_and_unbind(vpss_grp, sizeof(vpss_grp) / sizeof(vpss_grp));sample_aiisp_stop_venc_and_unbind(vpss_grp, sizeof(vpss_grp) / sizeof(vpss_grp[0]));
stop_vpss:// sample_aiisp_stop_vpss(vpss_grp);sample_aiisp_stop_vpss(vpss_grp[0]);
stop_vi:// sample_comm_vi_un_bind_vpss(master_pipe, vi_chn, vpss_grp, 0);sample_comm_vi_un_bind_vpss(master_pipe, vi_chn, vpss_grp[0], 0);sample_aibnr_stop_vi(vi_pipe, &vi_cfg);return ret;
}

sample_aiisp_common.c文件

// sample_aiisp_common.c#include <signal.h>
#include <limits.h>
#include "sample_aiisp_common.h"#define VENC_WIDTH 3840
#define VENC_HEIGTH 2160static sample_comm_venc_chn_param g_venc_chn_param = {.frame_rate           = 30, /* 30 is a number */.stats_time           = 2,  /* 2 is a number */.gop                  = 60, /* 60 is a number */.venc_size            = {VENC_WIDTH, VENC_HEIGTH},.size                 = -1,.profile              = 0,.is_rcn_ref_share_buf = TD_FALSE,.gop_attr             = {.gop_mode = OT_VENC_GOP_MODE_NORMAL_P,.normal_p = {2},},// .type                 = OT_PT_H265,.type                 = OT_PT_H264,.rc_mode              = SAMPLE_RC_CBR,
};static sample_comm_venc_chn_param g_venc_chn_param_small_chn = {.frame_rate           = 30, /* 30 is a number */.stats_time           = 2,  /* 2 is a number */.gop                  = 60, /* 60 is a number */.venc_size            = {720, 480},.size                 = -1,.profile              = 0,.is_rcn_ref_share_buf = TD_FALSE,.gop_attr             = {.gop_mode = OT_VENC_GOP_MODE_NORMAL_P,.normal_p = {2},},// .type                 = OT_PT_H265,.type                 = OT_PT_H264,.rc_mode              = SAMPLE_RC_CBR,
};volatile sig_atomic_t g_sig_flag = 0;td_void sample_aiisp_handle_sig(td_s32 signo)
{if (signo == SIGINT || signo == SIGTERM) {g_sig_flag = 1;}
}td_void sample_get_char(td_char *s)
{if (g_sig_flag == 1) {return;}printf("---------------press any key to %s!---------------\n", s);(td_void)getchar();
}sig_atomic_t sample_aiisp_get_sig(td_void)
{return g_sig_flag;
}static td_s32 sample_aiisp_check_fp(FILE *fp, td_char *model_file)
{if (fp == TD_NULL) {sample_print("open file err!\n");return TD_FAILURE;}printf("open %s success\n", model_file);return TD_SUCCESS;
}td_s32 sample_aiisp_load_mem(ot_aiisp_mem_info *mem, td_char *model_file)
{td_s32 ret;FILE *fp = TD_NULL;td_char path[PATH_MAX + 1] = {0};/* Get model file size */sample_aiisp_check_exps_return((strlen(model_file) > PATH_MAX) || realpath(model_file, path) == TD_NULL);fp = fopen(path, "rb");if (sample_aiisp_check_fp(fp, model_file) != TD_SUCCESS) {return TD_FAILURE;}ret = fseek(fp, 0L, SEEK_END);if (ret != TD_SUCCESS) {sample_print("fseek end failed!\n");goto fail_0;}mem->size = ftell(fp);if (mem->size <= 0) {sample_print("ftell failed!\n");goto fail_0;}ret = fseek(fp, 0L, SEEK_SET);if (ret != TD_SUCCESS) {sample_print("fseek set failed!\n");goto fail_0;}/* malloc model file mem */ret = ss_mpi_sys_mmz_alloc(&(mem->phys_addr), &(mem->virt_addr), "./aibnr_model", TD_NULL, mem->size);if (ret != TD_SUCCESS) {sample_print("malloc mmz failed!\n");goto fail_0;}ret = fread(mem->virt_addr, mem->size, 1, fp);if (ret != 1) {sample_print("read model file failed!\n");goto fail_1;}ret = fclose(fp);if (ret != 0) {sample_print("close file error\n");}return TD_SUCCESS;fail_1:ss_mpi_sys_mmz_free(mem->phys_addr, mem->virt_addr);mem->phys_addr = 0;mem->virt_addr = TD_NULL;
fail_0:(td_void)fclose(fp);return TD_FAILURE;
}td_void sample_aiisp_unload_mem(ot_aiisp_mem_info *param_mem)
{if ((param_mem->phys_addr != 0) && (param_mem->virt_addr != TD_NULL)) {(td_void)ss_mpi_sys_mmz_free(param_mem->phys_addr, param_mem->virt_addr);}
}static td_void sample_aiisp_get_default_vb_config(const ot_size *size, ot_vb_cfg *vb_cfg, td_u32 vb_cnt)
{ot_vb_calc_cfg calc_cfg = {0};ot_pic_buf_attr buf_attr = {0};(td_void)memset_s(vb_cfg, sizeof(ot_vb_cfg), 0, sizeof(ot_vb_cfg));vb_cfg->max_pool_cnt = 128; /* 128 blks */buf_attr.width         = size->width;buf_attr.height        = size->height;buf_attr.align         = OT_DEFAULT_ALIGN;buf_attr.bit_width     = OT_DATA_BIT_WIDTH_8;buf_attr.pixel_format  = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;buf_attr.compress_mode = OT_COMPRESS_MODE_NONE;buf_attr.video_format  = OT_VIDEO_FORMAT_LINEAR;ot_common_get_pic_buf_cfg(&buf_attr, &calc_cfg);vb_cfg->common_pool[0].blk_size = calc_cfg.vb_size;vb_cfg->common_pool[0].blk_cnt  = vb_cnt;
}#ifdef SAMPLE_MEM_SHARE_ENABLE
static td_void sample_aiisp_init_mem_share(td_void)
{td_u32 i;ot_vb_common_pools_id pools_id = {0};if (ss_mpi_vb_get_common_pool_id(&pools_id) != TD_SUCCESS) {sample_print("get common pool_id failed!\n");return;}for (i = 0; i < pools_id.pool_cnt; ++i) {ss_mpi_vb_pool_share_all(pools_id.pool[i]);}
}
#endiftd_s32 sample_aiisp_sys_init(ot_size *in_size, td_u32 vb_cnt)
{td_s32 ret;ot_vb_cfg vb_cfg = {0};td_u32 supplement_config;ot_vi_vpss_mode_type mode_type = OT_VI_OFFLINE_VPSS_ONLINE;sample_aiisp_get_default_vb_config(in_size, &vb_cfg, vb_cnt);supplement_config = OT_VB_SUPPLEMENT_BNR_MOT_MASK;ret = sample_comm_sys_init_with_vb_supplement(&vb_cfg, supplement_config);if (ret != TD_SUCCESS) {return TD_FAILURE;}#ifdef SAMPLE_MEM_SHARE_ENABLEsample_aiisp_init_mem_share();
#endifret = sample_comm_vi_set_vi_vpss_mode(mode_type, OT_VI_AIISP_MODE_DEFAULT);if (ret != TD_SUCCESS) {return TD_FAILURE;}return TD_SUCCESS;
}td_s32 sample_aiisp_start_vpss(ot_vpss_grp grp, ot_size *in_size)
{td_s32 ret;ot_vpss_grp_attr grp_attr = {0};sample_vpss_chn_attr vpss_chn_attr = {0};vpss_chn_attr.chn_enable[0] = TD_TRUE;vpss_chn_attr.chn_array_size = OT_VPSS_MAX_PHYS_CHN_NUM;sample_comm_vpss_get_default_grp_attr(&grp_attr);grp_attr.max_width  = in_size->width;grp_attr.max_height = in_size->height;sample_comm_vpss_get_default_chn_attr(&vpss_chn_attr.chn_attr[0]);vpss_chn_attr.chn_attr[0].width  = in_size->width;vpss_chn_attr.chn_attr[0].height = in_size->height;// 将 vpss grp0绑定到 vpss_chn1上// 这里增加一组 将vi数据源绑定给 vpssvpss_chn_attr.chn_enable[1] = TD_TRUE;vpss_chn_attr.chn_array_size = OT_VPSS_MAX_PHYS_CHN_NUM;vpss_chn_attr.chn_attr[1].width  = 720;vpss_chn_attr.chn_attr[1].height = 480;vpss_chn_attr.chn_attr[1].pixel_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;sample_comm_vpss_get_default_grp_attr(&grp_attr);grp_attr.max_width  = 720;grp_attr.max_height = 480;// 这里这样使用，没问题vpss_chn_attr.chn_attr[1].mirror_en = TD_FALSE;vpss_chn_attr.chn_attr[1].flip_en = TD_FALSE;vpss_chn_attr.chn_attr[1].border_en = TD_FALSE;vpss_chn_attr.chn_attr[1].width = 720;vpss_chn_attr.chn_attr[1].height = 480;vpss_chn_attr.chn_attr[1].depth = 0;vpss_chn_attr.chn_attr[1].chn_mode = OT_VPSS_CHN_MODE_USER;vpss_chn_attr.chn_attr[1].video_format = OT_VIDEO_FORMAT_LINEAR;vpss_chn_attr.chn_attr[1].dynamic_range = OT_DYNAMIC_RANGE_SDR8;vpss_chn_attr.chn_attr[1].pixel_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;vpss_chn_attr.chn_attr[1].compress_mode = OT_COMPRESS_MODE_NONE;vpss_chn_attr.chn_attr[1].aspect_ratio.mode = OT_ASPECT_RATIO_NONE;vpss_chn_attr.chn_attr[1].frame_rate.src_frame_rate = -1;vpss_chn_attr.chn_attr[1].frame_rate.dst_frame_rate = -1;// 这样使用，同样没问题// sample_comm_vpss_get_default_chn_attr(&vpss_chn_attr.chn_attr[1]);ret = sample_common_vpss_start(grp, &grp_attr, &vpss_chn_attr);if (ret != TD_SUCCESS) {return ret;}return TD_SUCCESS;
}td_s32 sample_aiisp_start_venc(ot_venc_chn venc_chn[], td_u32 venc_chn_len, td_u32 chn_num, ot_size *size)
{td_s32 i;td_s32 ret;g_venc_chn_param.venc_size.width        = size->width;g_venc_chn_param.venc_size.height       = size->height;g_venc_chn_param.size = sample_comm_sys_get_pic_enum(size);g_venc_chn_param_small_chn.venc_size.width        = 720;g_venc_chn_param_small_chn.venc_size.height       = 480;// g_venc_chn_param_small_chn.size = sample_comm_sys_get_pic_enum(size);    // 这个函数不能调用，调用后 venc_chn1通道没有流for (i = 0; i < (td_s32)chn_num && i < (td_s32)venc_chn_len; i++) {ret = sample_comm_venc_start(venc_chn[0], &g_venc_chn_param);if (ret != TD_SUCCESS) {goto exit;}// 小的 venc_chn分辨率绑定vpss视频源ret = sample_comm_venc_start(venc_chn[1], &g_venc_chn_param_small_chn);if (ret != TD_SUCCESS) {goto exit;}}// 获取视频流// 改为2，就多创建了一路码流。是创了两个 h264文件，但 index=1是一直没打印的ret = sample_comm_venc_start_get_stream(venc_chn, 2);// ret = sample_comm_venc_start_get_stream(venc_chn, chn_num);if (ret != TD_SUCCESS) {goto exit;}return TD_SUCCESS;exit:for (i = i - 1; i >= 0; i--) {sample_comm_venc_stop(venc_chn[i]);sample_comm_venc_stop(venc_chn[1]);}return TD_FAILURE;
}// 这里就是重点了
td_s32 sample_aiisp_start_venc_bind(ot_vpss_grp vpss_grp[], td_u32 grp_num, ot_size *in_size)
{// grp_num应该等于1td_u32 i;td_s32 ret;const ot_vpss_chn vpss_chn = 0;const ot_vpss_chn vpss_chn_1 = 1;   // 添加一个 vpss_chnot_venc_chn venc_chn[4] = {0, 1, 2, 3}; /* 4: max chn num, 0/1/2/3 chn id */// 函数作用是设置 venc_chn的属性。将 vpss的流绑定给 vencret = sample_aiisp_start_venc(venc_chn, 1, grp_num, in_size);// ret = sample_aiisp_start_venc(venc_chn, sizeof(venc_chn) / sizeof(ot_venc_chn), grp_num, in_size);if (ret != TD_SUCCESS) {goto start_venc_failed;}for (i = 0; i < grp_num; i++) {// 经检验 i等于 0sample_comm_vpss_bind_venc(vpss_grp[i], vpss_chn, venc_chn[i]);// 这里需将 vpss_chn1绑定给 venc吗，需要sample_comm_vpss_bind_venc(vpss_grp[0], vpss_chn_1, venc_chn[1]);}return TD_SUCCESS;start_venc_failed:return TD_FAILURE;
}td_void sample_aiisp_stop_vpss(ot_vpss_grp grp)
{td_bool chn_enable[OT_VPSS_MAX_PHYS_CHN_NUM] = {TD_TRUE, TD_FALSE, TD_FALSE};sample_common_vpss_stop(grp, chn_enable, OT_VPSS_MAX_PHYS_CHN_NUM);
}td_void sample_aiisp_stop_venc(ot_venc_chn venc_chn[], td_u32 venc_chn_len, td_u32 chn_num)
{td_u32 i;sample_comm_venc_stop_get_stream(chn_num);for (i = 0; i < chn_num && i < venc_chn_len; i++) {sample_comm_venc_stop(venc_chn[i]);}
}td_void sample_aiisp_stop_venc_and_unbind(ot_vpss_grp vpss_grp[], td_u32 grp_num)
{td_u32 i;const ot_vpss_chn vpss_chn = 0;ot_venc_chn venc_chn[4] = {0, 1, 2, 3}; /* 4: max chn num, 0/1/2/3 chn id */for (i = 0; i < grp_num; i++) {sample_comm_vpss_un_bind_venc(vpss_grp[i], vpss_chn, venc_chn[i]);}sample_aiisp_stop_venc(venc_chn, sizeof(venc_chn) / sizeof(ot_venc_chn), grp_num);
}td_s32 sample_aiisp_set_long_frame_mode(ot_vi_pipe vi_pipe, td_bool is_wdr_mode)
{td_s32 ret;ot_isp_exposure_attr exp_attr = {0};ot_isp_wdr_fs_attr fswdr_attr = {0};if (is_wdr_mode == TD_FALSE) {return TD_SUCCESS;}sample_get_char("set long frame mode");ret = ss_mpi_isp_get_exposure_attr(vi_pipe, &exp_attr);if (ret != TD_SUCCESS) {printf("ss_mpi_isp_get_exposure_attr error[0x%x]\n", ret);return TD_FAILURE;}exp_attr.auto_attr.fswdr_mode = OT_ISP_FSWDR_LONG_FRAME_MODE;ret = ss_mpi_isp_set_exposure_attr(vi_pipe, &exp_attr);if (ret != TD_SUCCESS) {printf("ss_mpi_isp_set_exposure_attr error[0x%x]\n", ret);return TD_FAILURE;}ret = ss_mpi_isp_get_fswdr_attr(vi_pipe, &fswdr_attr);if (ret != TD_SUCCESS) {printf("ss_mpi_isp_get_fswdr_attr error[0x%x]\n", ret);return TD_FAILURE;}fswdr_attr.wdr_merge_mode = OT_ISP_MERGE_WDR_MODE;ret = ss_mpi_isp_set_fswdr_attr(vi_pipe, &fswdr_attr);if (ret != TD_SUCCESS) {printf("ss_mpi_isp_set_fswdr_attr error[0x%x]\n", ret);return TD_FAILURE;}return ret;
}td_void sample_aiisp_get_default_cfg(sample_sns_type sns_type, ot_vi_pipe vi_pipe,ot_size *size, sample_vi_cfg *vi_cfg)
{sample_comm_vi_get_size_by_sns_type(sns_type, size);sample_comm_vi_get_default_vi_cfg(sns_type, vi_cfg);#ifdef OT_FPGAvi_cfg->pipe_info[vi_pipe].pipe_attr.frame_rate_ctrl.src_frame_rate = 30; /* 30fps */vi_cfg->pipe_info[vi_pipe].pipe_attr.frame_rate_ctrl.dst_frame_rate = 5; /* 5fps */
#endif
}

上述操作，可以多一路 venc_chn1的通道流

工程代码

通过网盘分享的文件：aiisp_easy_rtsp.zip
链接: https://pan.baidu.com/s/1ZNkiUpKQgV1cgB0bfrclSA 提取码: h4ib 
--来自百度网盘超级会员v5的分享