S32 __video_stream_support_hdr_init_for_avs(TP_STRM_ID_E strm_id, const TP_STREAM_ATTR_S *pAttr)
{
HD_RESULT ret = HD_OK;
UINT32 framerate = 1;
UINT32 vsp_cnt = 0, vprc_pipe = 0, vsp_base_pipe = 0;
HD_DIM avs_max_dim = {0};
UINT16 vsp_out_w = 0, vsp_out_h = 0;
LOCAL VENDOR_VIDEOPROC_VSP_CFG bak_vsp_cfg = {0};
g_distance_change_flag = FALSE;
int i = 0, blk_size = 0;
VIDEO_CAP_MAIN video_cap_main = {0};
int sensor_id = 0;
int sensor_num = 2;
vsp_cnt = g_strm_param[0][0].avs_para.max_chn_cnt;
vsp_base_pipe = g_strm_param[0][0].avs_para.base_chn;
vsp_out_w = g_strm_param[0][0].avs_para.avs_out_w;
vsp_out_h = g_strm_param[0][0].avs_para.avs_out_h;
if(strm_id == STRM_ID_MAIN)
{
if (0 == ds_read(VIDEO_CAP_MAIN_PATH, &video_cap_main, sizeof(VIDEO_CAP_MAIN)))
{
MPP_ERROR("ds read <%s> error.", VIDEO_CAP_MAIN_PATH);
return HD_ERR_NG;
}
if(g_videocap_start == FALSE)
{
ret = set_hdr_cfg(pAttr->hdr);
if (ret != HD_OK) {
MPP_ERROR("set hdr cfg=%d\n", ret);
return HD_ERR_NG;
}
/* VCAP0 dev open & path set*/
// set videocap config
ret = set_cap_cfg(&g_video_avdc_stream[0][0].cap_ctrl);
if (ret != HD_OK) {
MPP_ERROR("set cap-cfg fail=%d\n", ret);
return HD_ERR_NG;
}
//open capture module
ret = hd_videocap_open(HD_VIDEOCAP_0_IN_0, HD_VIDEOCAP_0_OUT_0, &g_video_avdc_stream[0][0].cap_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videocap_open fail=%d\n", ret);
return HD_ERR_NG;
}
// get videocap capability
ret = get_cap_caps(g_video_avdc_stream[0][0].cap_ctrl, &g_video_avdc_stream[0][0].cap_syscaps);
if (ret != HD_OK) {
MPP_ERROR("get cap-caps fail=%d\n", ret);
return HD_ERR_NG;
}
// set videocap parameter
ret = set_cap_param(g_video_avdc_stream[0][0].cap_path, &g_video_avdc_stream[0][0].cap_dim, NULL);
if (ret != HD_OK) {
MPP_ERROR("set cap fail=%d\n", ret);
return HD_ERR_NG;
}
/* VCAP1 dev open & path set*/
// set videocap config
ret = set_cap2_cfg(&g_video_avdc_stream[1][0].cap_ctrl);
if (ret != HD_OK) {
MPP_ERROR("set cap-cfg fail=%d\n", ret);
return HD_ERR_NG;
}
//open capture module
ret = hd_videocap_open(HD_VIDEOCAP_2_IN_0, HD_VIDEOCAP_2_OUT_0, &g_video_avdc_stream[1][0].cap_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videocap_open fail=%d\n", ret);
return HD_ERR_NG;
}
// get videocap capability
ret = get_cap_caps(g_video_avdc_stream[1][0].cap_ctrl, &g_video_avdc_stream[1][0].cap_syscaps);
if (ret != HD_OK) {
MPP_ERROR("get cap-caps fail=%d\n", ret);
return HD_ERR_NG;
}
// set videocap parameter
ret = set_cap2_param(g_video_avdc_stream[1][0].cap_path, &g_video_avdc_stream[1][0].cap_dim, NULL);
if (ret != HD_OK) {
MPP_ERROR("set cap fail=%d\n", ret);
return HD_ERR_NG;
}
//修改点一 if(VDO_SIZE_W != pAttr->strm_res.res_w && VDO_SIZE_H != pAttr->strm_res.res_h)
/* VPRC0 & VPRC1 dev open */
// set videoproc0 config
ret = set_proc_cfg(&g_video_avdc_stream[0][0].proc_ctrl, &g_video_avdc_stream[0][0].proc_max_dim);
if (ret != HD_OK) {
MPP_ERROR("set proc-cfg fail=%d\n", ret);
return HD_ERR_NG;
}
// set videoproc1 config
ret = set_proc2_cfg(&g_video_avdc_stream[1][0].proc_ctrl, &g_video_avdc_stream[1][0].proc_max_dim);
if (ret != HD_OK) {
MPP_ERROR("set proc-cfg fail=%d\n", ret);
return HD_ERR_NG;
}
//修改点二 aiisp_isp(get_hdr_cfg());
/* set vsp cfg for any-view stiching */
// set vsp ctrl for avs
vprc_pipe = vsp_base_pipe;
avs_max_dim.w = vsp_out_w;
avs_max_dim.h = vsp_out_h;
ret = set_proc_cfg_for_avs(HD_VIDEOPROC_CTRL(vprc_pipe), &g_video_avdc_stream[0][0].avs_proc[0].proc_ctrl, &avs_max_dim,
&g_video_avdc_stream[0][0].avs_proc[0], vsp_base_pipe, &bak_vsp_cfg);
if (ret != HD_OK)
{
MPP_ERROR("set_proc_cfg_for_avs fail=%d\n", ret);
return HD_ERR_NG;
}
// set scl for alg -- 需兼容深度学习算法流
vprc_pipe = vsp_base_pipe + 1;
avs_max_dim.w = ALIGN_CEIL_8(atoi(video_cap_main.resolutions[1]));
avs_max_dim.h = ALIGN_CEIL_8(atoi(strchr(video_cap_main.resolutions[1], '*') + 1));
ret = set_proc_cfg_for_scale(HD_VIDEOPROC_CTRL(vprc_pipe), &g_video_avdc_stream[0][0].avs_proc[0].scl_proc_ctrl, &avs_max_dim);
if (ret != HD_OK)
{
MPP_ERROR("set_proc_cfg_for_scale(avs) fail=%d\n", ret);
return HD_ERR_NG;
}
}
MPP_ERROR("[VIDEO Attr]=====>");
MPP_ERROR("avs resolution: %d*%d.", pAttr->avs_out_res.res_w, pAttr->avs_out_res.res_h);
MPP_ERROR("proj resolution: %d*%d.", pAttr->src_proj_res.res_w, pAttr->src_proj_res.res_h);
MPP_ERROR("fusion overlay width: %d.", pAttr->fusion_overlay_w);
#if SMART_STITCH
/* 初始化时从ds配置读取smart stitch开关状态 */
SMART_STITCH_CONFIG smart_stitch_config = {0};
if (0 == ds_read(SMART_STITCH_CONFIG_PATH, &smart_stitch_config, sizeof(SMART_STITCH_CONFIG)))
{
MPP_ERROR("ds read <%s> error.", SMART_STITCH_CONFIG_PATH);
return -1;
}
g_is_smart_stitch_open = (smart_stitch_config.enabled == SWITCH_ON) ? TRUE:FALSE;
#endif
ret = prepare_stitch_info(TRUE, &g_distance_change_flag);
if (ret != HD_OK)
{
MPP_ERROR("prepare_stitch_info=%d\n", ret);
return HD_ERR_NG;
}
/* 修改静态拼接距离距离导致overlap变化 需要reload fusion table */
if(g_distance_change_flag)
{
MPP_ERROR("overlap changed, reset vsp cfg! vsp_ovlp_w[0]=%d", vsp_ovlp_w[0]);
for(i = 0; i < vsp_base_pipe; i++)
{
bak_vsp_cfg.ovlp_width[i] = vsp_ovlp_w[i];
bak_vsp_cfg.scale_out_size[i].w = vsp_vpe_out_w[i];
MPP_ERROR("ovlp_width=%d, scale_out_size.h=%d", bak_vsp_cfg.ovlp_width[i], bak_vsp_cfg.scale_out_size[i].h);
if(bak_vsp_cfg.ovlp_width[i] != 0)
{
blk_size = VDO_YUV_BUFSIZE(bak_vsp_cfg.ovlp_width[i], bak_vsp_cfg.scale_out_size[i].h, HD_VIDEO_PXLFMT_Y8);
// init fusion table
init_fusion_tbl(g_video_avdc_stream[0][0].avs_proc[0].fusion_va[i], bak_vsp_cfg.ovlp_width[i],
bak_vsp_cfg.scale_out_size[i].h);
// flush cache
hd_common_mem_flush_cache((void *)g_video_avdc_stream[0][0].avs_proc[0].fusion_va[i], blk_size);
}
}
ret = vendor_videoproc_set(g_video_avdc_stream[0][0].avs_proc[0].proc_ctrl, VENDOR_VIDEOPROC_PARAM_VSP_CFG, &bak_vsp_cfg);
if(HD_OK != ret)
{
MPP_ERROR("vendor_videoproc_set error %d", ret);
return HD_ERR_NG;
}
MPP_ERROR("reset vsp cfg finished");
}
// set vsp parameters for avts, needed in every single reload.
avs_max_dim.w = VDO_SIZE_W; // 当前赋值暂无用。
avs_max_dim.h = VDO_SIZE_H; // 当前赋值暂无用。
ret = set_avs_effect_cfg(&g_video_avdc_stream[0][0].avs_proc[0], &avs_max_dim);
if (ret != HD_OK)
{
MPP_ERROR("set_avs_effect_cfg fail=%d\n", ret);
return HD_ERR_NG;
}
g_strm_param[0][strm_id].u32CapWidth = pAttr->strm_res.res_w;
g_strm_param[0][strm_id].u32CapHeight = pAttr->strm_res.res_h;
// set videocap parameter
HD_DIM crop_dim;
HD_VIDEOCAP_OUT video_out_param = {0};
crop_dim.w = VDO_SIZE_W;
crop_dim.h = VDO_SIZE_H;
ret = set_cap_param(g_video_avdc_stream[0][0].cap_path, &g_video_avdc_stream[0][0].cap_dim, &crop_dim);
if (ret != HD_OK) {
MPP_ERROR("set cap fail=%d\n", ret);
return -1;
}
hd_videocap_get(g_video_avdc_stream[0][0].cap_path, HD_VIDEOCAP_PARAM_OUT, &video_out_param);
if(video_out_param.dim.w != 0 && video_out_param.dim.h != 0 &&
video_out_param.dim.w == VDO_SIZE_W && video_out_param.dim.h != VDO_SIZE_H)
{
HD_VIDEOCAP_CROP video_crop_param = {0};
video_crop_param.mode = HD_CROP_ON;
video_crop_param.win.rect.x = 0;
video_crop_param.win.rect.y = 0;
video_crop_param.win.rect.w = video_out_param.dim.w;
video_crop_param.win.rect.h = video_out_param.dim.h;
video_crop_param.align.w = 4;
video_crop_param.align.h = 4;
hd_videocap_set(g_video_avdc_stream[0][0].cap_path, HD_VIDEOCAP_PARAM_IN_CROP, &video_crop_param);
}
else
{
HD_VIDEOCAP_CROP video_crop_param = {0};
video_crop_param.mode = HD_CROP_OFF;
hd_videocap_set(g_video_avdc_stream[0][0].cap_path, HD_VIDEOCAP_PARAM_IN_CROP, &video_crop_param);
}
ret = set_cap2_param(g_video_avdc_stream[1][0].cap_path, &g_video_avdc_stream[1][0].cap_dim, &crop_dim);
if (ret != HD_OK) {
MPP_ERROR("set cap fail=%d\n", ret);
return -1;
}
hd_videocap_get(g_video_avdc_stream[1][0].cap_path, HD_VIDEOCAP_PARAM_OUT, &video_out_param);
if(video_out_param.dim.w != 0 && video_out_param.dim.h != 0 &&
video_out_param.dim.w == VDO_SIZE_W && video_out_param.dim.h != VDO_SIZE_H)
{
HD_VIDEOCAP_CROP video_crop_param = {0};
video_crop_param.mode = HD_CROP_ON;
video_crop_param.win.rect.x = 0;
video_crop_param.win.rect.y = 0;
video_crop_param.win.rect.w = video_out_param.dim.w;
video_crop_param.win.rect.h = video_out_param.dim.h;
video_crop_param.align.w = 4;
video_crop_param.align.h = 4;
hd_videocap_set(g_video_avdc_stream[1][0].cap_path, HD_VIDEOCAP_PARAM_IN_CROP, &video_crop_param);
}
else
{
HD_VIDEOCAP_CROP video_crop_param = {0};
video_crop_param.mode = HD_CROP_OFF;
hd_videocap_set(g_video_avdc_stream[1][0].cap_path, HD_VIDEOCAP_PARAM_IN_CROP, &video_crop_param);
}
// set main encoder param
ret = set_enc_param(g_video_avdc_stream[0][strm_id].enc_path, pAttr, &venc_para, &g_video_avdc_stream[0][strm_id].is_reconfig_enc_para, 0);
if (ret != HD_OK) {
MPP_ERROR("set enc fail=%d\n", ret);
return -1;
}
//修改点三 g_video_avdc_stream[0][0].proc_max_dim.w = pAttr->strm_res.res_w;ret = set_proc_cfg(&g_video_avdc_stream[0][0].proc_ctrl, &g_video_avdc_stream[0][0].proc_max_dim);
if(get_factory_mode())
{
// 拼接产测模式下限制编码帧率，由于需额外出sensor0 1两路主码流，防止超过538 codec性能瓶颈
/* 修改venc in帧率 */
framerate = AVS_FACTORY_MAX_ENC_FRM_RATE;
HD_VIDEOENC_IN video_in_param = {0};
ret = hd_videoenc_get(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_get fail=%d\n", ret);
return -1;
}
video_in_param.frc = HD_VIDEO_FRC_RATIO(framerate, video_in_param.frc);
ret = hd_videoenc_set(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_set fail=%d\n", ret);
return -1;
}
}
HD_DIM avs_src_dim;
avs_src_dim.w = VDO_SIZE_W;
avs_src_dim.h = VDO_SIZE_H;
/* set VPRC0 OUT0 -- SENSOR1对应的vcap0设置、绑定vprc */
// open vprc out0
ret = hd_videoproc_open(HD_VIDEOPROC_0_IN_0, HD_VIDEOPROC_0_OUT_0, &g_video_avdc_stream[0][strm_id].proc_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open fail=%d\n", ret);
return -1;
}
//修改点四 ret = set_proc_param(g_video_avdc_stream[0][strm_id].proc_path, strm_id, &g_video_avdc_stream[0][0].proc_max_dim);
// 拼接src out需配置尺寸参数
ret = set_proc_param(g_video_avdc_stream[0][strm_id].proc_path, strm_id, &avs_src_dim);
if (ret != HD_OK) {
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 双目拼接机型需要使用左右目YUV420原图做色差校正检验（产测模式）和自动拼接，不压缩
ret = set_proc_pxlfmt_for_avs(g_video_avdc_stream[0][strm_id].proc_path);
if(ret != HD_OK)
{
MPP_ERROR("set proc pxlfmt fail=%d\n", ret);
return -1;
}
// vcap0和rawall pipe in绑定
if(g_videocap_start == FALSE) {
ret = hd_videocap_bind(HD_VIDEOCAP_0_OUT_0, HD_VIDEOPROC_0_IN_0);
if (ret != HD_OK) {
MPP_ERROR("hd_videocap_bind fail=%d\n", ret);
return -1;
}
}
/* set VPRC1 OUT0 -- SENSOR2对应的vcap1设置、绑定vprc */
// open vprc out0
ret = hd_videoproc_open(HD_VIDEOPROC_1_IN_0, HD_VIDEOPROC_1_OUT_0, &g_video_avdc_stream[1][strm_id].proc_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open fail=%d\n", ret);
return -1;
}
//修改点五
// 拼接src out需配置尺寸参数
ret = set_proc_param(g_video_avdc_stream[1][strm_id].proc_path, strm_id, &avs_src_dim);
if (ret != HD_OK) {
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 双目拼接机型需要使用左右目YUV420原图做色差校正检验（产测模式）和自动拼接，不压缩
ret = set_proc_pxlfmt_for_avs(g_video_avdc_stream[1][strm_id].proc_path);
if(ret != HD_OK)
{
MPP_ERROR("set proc pxlfmt fail=%d\n", ret);
return -1;
}
// vcap1和rawall pipe in绑定
if(g_videocap_start == FALSE) {
ret = hd_videocap_bind(HD_VIDEOCAP_2_OUT_0, HD_VIDEOPROC_1_IN_0);
if (ret != HD_OK) {
MPP_ERROR("hd_videocap_bind fail=%d\n", ret);
return -1;
}
}
vprc_pipe = vsp_base_pipe;
/* vsp 各out path设置与open */
// open拼接proc的主码流输出vprc path
ret = hd_videoproc_open(HD_VIDEOPROC_IN(vprc_pipe, 0), HD_VIDEOPROC_OUT(vprc_pipe, AVS_PROC_ID_MAIN),
&g_video_avdc_stream[0][0].avs_proc[0].proc_path_main);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open avs[main] fail=%d\n", ret);
return -1;
}
// 设置vsp path out参数
HD_DIM avs_main_dim;
avs_main_dim.w = AVS_OUT_DEF_W;
avs_main_dim.h = AVS_OUT_DEF_H;
ret = set_proc_param(g_video_avdc_stream[0][0].avs_proc[0].proc_path_main, strm_id, &avs_main_dim);
if (ret != HD_OK) {
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
#if SMART_STITCH
/* 非产测模式下打开动态拼接通道 */
if(!get_factory_mode() /* && g_is_smart_stitch_open == TRUE*/)
{
// 初始化SMART_STITCH 双目base_chn=2，overlap id=0
ret = smart_stitch_initialize(&g_video_avdc_stream[0][0].avs_proc[0], g_strm_param[0][0].avs_para.base_chn, 0);
if (ret != HD_OK) {
MPP_ERROR("stitch_initialize fail=%d\n", ret);
return -1;
}
}
#endif
// 处理主码流非最大分辨率情况
// open拼接的主码流输出vprc path
if (pAttr->avs_out_res.res_w != AVS_OUT_DEF_W || pAttr->avs_out_res.res_h != AVS_OUT_DEF_H)
{
UINT32 scale_pipe = vprc_pipe + 1;
ret = hd_videoproc_open(HD_VIDEOPROC_IN(scale_pipe, 0), HD_VIDEOPROC_OUT(scale_pipe, AVS_SCL_OUT_ID_SCL_MAIN),
&g_video_avdc_stream[0][0].avs_proc[0].proc_path_scl_src);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open scale[main] fail=%d\n", ret);
return -1;
}
// 设置avs scl path out参数
ret = set_proc_param(g_video_avdc_stream[0][0].avs_proc[0].proc_path_scl_src, strm_id, NULL);
if (ret != HD_OK) {
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 绑定对应的编码通道
ret = hd_videoproc_bind(HD_VIDEOPROC_OUT(scale_pipe, AVS_SCL_OUT_ID_SCL_MAIN), HD_VIDEOENC_IN(0, AVS_VENC_OUT_ID_MAIN));
if (ret != HD_OK) {
MPP_ERROR("AVS_VENC_OUT_ID_MAIN bind fail=%d\n", ret);
return -1;
}
g_video_main_is_max_res = FALSE;
}
else
{
// 绑定对应的编码通道
ret = hd_videoproc_bind(HD_VIDEOPROC_OUT(vprc_pipe, AVS_PROC_ID_MAIN), HD_VIDEOENC_IN(0, AVS_VENC_OUT_ID_MAIN));
if (ret != HD_OK)
{
MPP_ERROR("STRM_ID_MAIN 0 bind fail=%d\n", ret);
return -1;
}
g_video_main_is_max_res = TRUE;
}
/* 设置stitch id */
for (sensor_id = 0; sensor_id < sensor_num; sensor_id++)
{
AET_STITCH_ID ae_stitch = {0};
AWBT_STITCH_ID awb_stitch = {0};
ae_stitch.id = g_isp_id[sensor_id];
awb_stitch.id = g_isp_id[sensor_id];
if (get_hdr_cfg() == TP_VIDEO_HDR_ON)
{
ae_stitch.stitch_id.stitch_id_1 = 0xffff0000 | (g_isp_id[0] + 1) | (g_isp_id[0] << 4) | ((g_isp_id[1] + 1) << 8) | (g_isp_id[1] << 12);
ae_stitch.stitch_id.stitch_id_2 = 0xffffffff;
awb_stitch.stitch_id.stitch_id_1 = ae_stitch.stitch_id.stitch_id_1;
awb_stitch.stitch_id.stitch_id_2 = ae_stitch.stitch_id.stitch_id_2;
}
else
{
ae_stitch.stitch_id.stitch_id_1 = 0xffffff00 | g_isp_id[0] | (g_isp_id[1] << 4);
ae_stitch.stitch_id.stitch_id_2 = 0xffffffff;
awb_stitch.stitch_id.stitch_id_1 = ae_stitch.stitch_id.stitch_id_1;
awb_stitch.stitch_id.stitch_id_2 = ae_stitch.stitch_id.stitch_id_2;
}
if (vendor_isp_set_ae(AET_ITEM_STITCH_ID, &ae_stitch) != HD_OK)
{
MPP_ERROR("set ae stitch_id error");
return ERROR;
}
if (vendor_isp_set_awb(AWBT_ITEM_STITCH_ID, &awb_stitch) != HD_OK)
{
MPP_ERROR("set awb stitch_id error");
return ERROR;
}
MPP_ERROR("id = %d, stitch id1 = 0x%x \n", awb_stitch.id, awb_stitch.stitch_id.stitch_id_1);
}
}
else if(strm_id == STRM_ID_MINOR)
{
g_strm_param[0][strm_id].u32CapHeight = pAttr->strm_res.res_h;
g_strm_param[0][strm_id].u32CapWidth = pAttr->strm_res.res_w;
ret = set_enc_param(g_video_avdc_stream[0][strm_id].enc_path, pAttr, &sub_venc_para, &g_video_avdc_stream[0][strm_id].is_reconfig_enc_para, 0);
if (ret != HD_OK) {
MPP_ERROR("set enc fail=%d\n", ret);
return -1;
}
if(get_factory_mode())
{
// 拼接产测模式下限制编码帧率，由于需额外出sensor0 1两路主码流，防止超过538 codec性能瓶颈
/* 修改venc in帧率 */
framerate = AVS_FACTORY_MAX_ENC_FRM_RATE;
HD_VIDEOENC_IN video_in_param = {0};
ret = hd_videoenc_get(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_get fail=%d\n", ret);
return -1;
}
video_in_param.frc = HD_VIDEO_FRC_RATIO(framerate, video_in_param.frc);
ret = hd_videoenc_set(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_set fail=%d\n", ret);
return -1;
}
}
vprc_pipe = vsp_base_pipe + vsp_cnt;
// open拼接的子码流输出vprc path
ret = hd_videoproc_open(HD_VIDEOPROC_IN(vprc_pipe, 0), HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_MINOR),
&g_video_avdc_stream[0][strm_id].proc_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open avs[minor] fail=%d\n", ret);
return -1;
}
// 设置avs scl path out参数
ret = set_proc_param(g_video_avdc_stream[0][strm_id].proc_path, strm_id, NULL);
if (ret != HD_OK) {
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 绑定对应的编码通道
ret = hd_videoproc_bind(HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_MINOR), HD_VIDEOENC_IN(0, AVS_VENC_OUT_ID_MINOR));
if (ret != HD_OK) {
MPP_ERROR("STRM_ID_MINOR 1 bind fail=%d\n", ret);
return -1;
}
}
else if(strm_id == STRM_ID_JPEG)
{
ret = set_enc_param(g_video_avdc_stream[0][strm_id].enc_path, pAttr, NULL, &g_video_avdc_stream[0][strm_id].is_reconfig_enc_para, 0);
if (ret != HD_OK)
{
MPP_ERROR("set enc fail=%d\n", ret);
return -1;
}
/* 修改venc in帧率 */
framerate=pAttr->framerate.low / pAttr->framerate.high;
HD_VIDEOENC_IN video_in_param = {0};
ret = hd_videoenc_get(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_get fail=%d\n", ret);
return -1;
}
video_in_param.frc = HD_VIDEO_FRC_RATIO(framerate, framerate);
ret = hd_videoenc_set(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_set fail=%d\n", ret);
return -1;
}
vprc_pipe = vsp_base_pipe + vsp_cnt;
// open拼接的第二子码流输出vprc path
ret = hd_videoproc_open(HD_VIDEOPROC_IN(vprc_pipe, 0), HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_JPEG),
&g_video_avdc_stream[0][strm_id].proc_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open avs[jpeg] fail=%d\n", ret);
return -1;
}
// 设置vsp scl path out参数
ret = set_proc_param(g_video_avdc_stream[0][strm_id].proc_path, strm_id, NULL);
if (ret != HD_OK) {
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 修改vprc out帧率
ret = set_proc_param_framerate(g_video_avdc_stream[0][strm_id].proc_path, framerate);
// 绑定对应的编码通道
ret = hd_videoproc_bind(HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_JPEG), HD_VIDEOENC_IN(0, AVS_VENC_OUT_ID_JPEG));
if (ret != HD_OK) {
MPP_ERROR("STRM_ID_JPEG 2 bind fail=%d\n", ret);
return -1;
}
}
else if(strm_id == STRM_ID_ISP)
{
vprc_pipe = vsp_base_pipe + vsp_cnt;
ret = hd_videoproc_open(HD_VIDEOPROC_IN(vprc_pipe, 0), HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_ISP),
&g_video_avdc_stream[0][strm_id].proc_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_open fail=%d\n", ret);
return -1;
}
HD_DIM isp_dim = {0};
isp_dim.w = ISP_FRAME_WIDTH;
isp_dim.h = ISP_FRAME_HEIGHT;
framerate = pAttr->framerate.low / pAttr->framerate.high;
ret = set_proc_param_extend(g_video_avdc_stream[0][strm_id].proc_path, HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_MINOR),
NULL, &isp_dim, HD_VIDEO_DIR_NONE, framerate);
if (ret != HD_OK) {
MPP_ERROR("set proc avs isp fail=%d\n", ret);
return -1;
}
}
else if(strm_id == STRM_ID_DLA)
{
#ifdef DLA_REC_STREAM_SUPPORT
/* 人车属性/人头/人脸模式下启动识别流 */
if (g_face_enabled || g_people_enabled || g_vehicle_enabled)
{
if (g_is_dla_hd_videoproc_open != TRUE)
{
vprc_pipe = vsp_base_pipe + vsp_cnt;
ret = hd_videoproc_open(HD_VIDEOPROC_IN(vprc_pipe, 0), HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_DLA_REC_STRM),
&g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoproc_open fail=%d\n", ret);
return -1;
}
}
if ((0 == g_video_attr[STRM_ID_DLA_REC].strm_res.res_w) ||
(0 == g_video_attr[STRM_ID_DLA_REC].strm_res.res_h) ||
(DLA_REC_FRAME_WIDTH < g_video_attr[STRM_ID_DLA_REC].strm_res.res_w) ||
(DLA_REC_FRAME_HEIGHT < g_video_attr[STRM_ID_DLA_REC].strm_res.res_h))
{
g_strm_dla_rec_enabled = FALSE;
}
else
{
g_strm_dla_rec_enabled = TRUE;
}
MPP_ERROR("g_strm_dla_rec_enabled:%d", g_strm_dla_rec_enabled);
MPP_ERROR("(pAttr + DLA_REC)->strm_res.res_w:%d", g_video_attr[STRM_ID_DLA_REC].strm_res.res_w);
MPP_ERROR("(pAttr + DLA_REC)->strm_res.res_h:%d", g_video_attr[STRM_ID_DLA_REC].strm_res.res_h);
MPP_ERROR("(pAttr + DLA_REC)->framerate.low:%d", g_video_attr[STRM_ID_DLA_REC].framerate.low);
MPP_ERROR("(pAttr + DLA_REC)->framerate.high:%d", g_video_attr[STRM_ID_DLA_REC].framerate.high);
if (g_strm_dla_rec_enabled == TRUE)
{
HD_DIM dla_rec_dim;
dla_rec_dim.w = g_video_attr[STRM_ID_DLA_REC].strm_res.res_w;
dla_rec_dim.h = g_video_attr[STRM_ID_DLA_REC].strm_res.res_h;
framerate = g_video_attr[STRM_ID_DLA_REC].framerate.low / g_video_attr[STRM_ID_DLA_REC].framerate.high;
// 扩展通道接入到副码流vprc
// ret = set_proc_param_extend(g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path,HD_VIDEOPROC_0_OUT_1 , NULL, &dla_rec_dim, HD_VIDEO_DIR_NONE,framerate);
// 设置物理通道参数
ret = set_proc_param(g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path, HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_DLA_REC_STRM), &dla_rec_dim);
if (ret != HD_OK)
{
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 修改vprc out帧率
ret = set_proc_param_framerate(g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path, framerate);
if (ret != HD_OK)
{
MPP_ERROR("set proc fail=%d\n", ret);
return -1;
}
// 修改识别流 depth为1
HD_VIDEOPROC_OUT video_out_param = {0};
ret = hd_videoproc_get(g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path, HD_VIDEOPROC_PARAM_OUT, &video_out_param);
video_out_param.depth = 1;
ret = hd_videoproc_set(g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path, HD_VIDEOPROC_PARAM_OUT, &video_out_param);
}
}
#endif
if ((0 != g_video_attr[STRM_ID_DLA].strm_res.res_w) &&
(0 != g_video_attr[STRM_ID_DLA].strm_res.res_h) &&
(0 != pAttr->framerate.high))
{
vprc_pipe = vsp_base_pipe + vsp_cnt;
if (g_is_dla_hd_videoproc_open != TRUE)
{
ret = hd_videoproc_open(HD_VIDEOPROC_IN(vprc_pipe, 0), HD_VIDEOPROC_OUT(vprc_pipe, AVS_SCL_OUT_ID_DLA),
&g_video_avdc_stream[0][strm_id].proc_path);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoproc_open fail=%d\n", ret);
return -1;
}
g_is_dla_hd_videoproc_open = TRUE;
}
MPP_ERROR("DLA_DET width max: %d",DLA_FRAME_WIDTH);
MPP_ERROR("DLA_DET height max: %d",DLA_FRAME_HEIGHT);
MPP_ERROR("(pAttr + DLA_DET)->strm_res.res_w:%d", g_video_attr[STRM_ID_DLA].strm_res.res_w);
MPP_ERROR("(pAttr + DLA_DET)->strm_res.res_h:%d", g_video_attr[STRM_ID_DLA].strm_res.res_h);
MPP_ERROR("(pAttr + DLA_DET)->framerate.low:%d", g_video_attr[STRM_ID_DLA].framerate.low);
MPP_ERROR("(pAttr + DLA_DET)->framerate.high:%d", g_video_attr[STRM_ID_DLA].framerate.high);
if(g_video_attr[STRM_ID_DLA].strm_res.res_w > DLA_FRAME_WIDTH || g_video_attr[STRM_ID_DLA].strm_res.res_h > DLA_FRAME_HEIGHT)
{
MPP_ERROR("DLA_DET resolution out of range");
return -1;
}
HD_DIM dla_dim = {0};
U32 src_path = AVS_SCL_OUT_ID_MINOR;
dla_dim.w = g_video_attr[STRM_ID_DLA].strm_res.res_w;
dla_dim.h = g_video_attr[STRM_ID_DLA].strm_res.res_h;
framerate = pAttr->framerate.low / pAttr->framerate.high;;
/*存在识别流时，将识别流作为检测流物理通道；否则将子码流作为检测流物理通道*/
if(TRUE == g_strm_dla_rec_enabled)
{
src_path = AVS_SCL_OUT_ID_DLA_REC_STRM;
framerate = 0;
}
ret = set_proc_param_extend(g_video_avdc_stream[0][strm_id].proc_path, HD_VIDEOPROC_OUT(vprc_pipe, src_path),
NULL, &dla_dim, HD_VIDEO_DIR_NONE,framerate);
if (ret != HD_OK) {
MPP_ERROR("set proc avs dla fail=%d\n", ret);
return -1;
}
}
}
#ifdef MAIN_STREAM_SEC_ENABLE
else if(strm_id == STRM_ID_MAIN_SEC)
{
if(get_factory_mode())
{
g_strm_param[0][strm_id].u32CapHeight = pAttr->strm_res.res_h;
g_strm_param[0][strm_id].u32CapWidth = pAttr->strm_res.res_w;
ret = set_enc_param(g_video_avdc_stream[0][strm_id].enc_path, pAttr, &venc_para, &g_video_avdc_stream[0][strm_id].is_reconfig_enc_para, 0);
if (ret != HD_OK) {
MPP_ERROR("set enc fail=%d\n", ret);
return -1;
}
/* 修改venc in帧率 */
framerate = pAttr->framerate.low / pAttr->framerate.high;
HD_VIDEOENC_IN video_in_param = {0};
ret = hd_videoenc_get(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_get fail=%d\n", ret);
return -1;
}
video_in_param.frc = HD_VIDEO_FRC_RATIO(framerate, video_in_param.frc);
ret = hd_videoenc_set(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_set fail=%d\n", ret);
return -1;
}
// 绑定对应的编码通道
ret = hd_videoproc_bind(HD_VIDEOPROC_OUT(0, 0), HD_VIDEOENC_IN(0, AVS_VENC_OUT_ID_MAIN_SEC));
if (ret != HD_OK) {
MPP_ERROR("STRM_ID_MINOR 1 bind fail=%d\n", ret);
return -1;
}
}
}
#endif
#ifdef MINOR_STREAM_SEC_ENABLE
else if(strm_id == STRM_ID_MINOR_SEC)
{
// TODO
}
#endif
#ifdef MAIN_STREAM_THD_ENABLE
else if(strm_id == STRM_ID_MAIN_THD)
{
if(get_factory_mode())
{
g_strm_param[0][strm_id].u32CapHeight = pAttr->strm_res.res_h;
g_strm_param[0][strm_id].u32CapWidth = pAttr->strm_res.res_w;
ret = set_enc_param(g_video_avdc_stream[0][strm_id].enc_path, pAttr, &venc_para, &g_video_avdc_stream[0][strm_id].is_reconfig_enc_para, 0);
if (ret != HD_OK) {
MPP_ERROR("set enc fail=%d\n", ret);
return -1;
}
/* 修改venc in帧率 */
framerate = pAttr->framerate.low / pAttr->framerate.high;
HD_VIDEOENC_IN video_in_param = {0};
ret = hd_videoenc_get(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_get fail=%d\n", ret);
return -1;
}
video_in_param.frc = HD_VIDEO_FRC_RATIO(framerate, video_in_param.frc);
ret = hd_videoenc_set(g_video_avdc_stream[0][strm_id].enc_path, HD_VIDEOENC_PARAM_IN, &video_in_param);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoenc_set fail=%d\n", ret);
return -1;
}
// 绑定对应的编码通道
ret = hd_videoproc_bind(HD_VIDEOPROC_OUT(1, 0), HD_VIDEOENC_IN(0, AVS_VENC_OUT_ID_MAIN_THD));
if (ret != HD_OK) {
MPP_ERROR("STRM_ID_MINOR 1 bind fail=%d\n", ret);
return -1;
}
}
}
#endif
#ifdef MINOR_STREAM_THD_ENABLE
else if(strm_id == STRM_ID_MINOR_THD)
{
// TODO
}
#endif
memcpy(&g_strm_param[0][strm_id].roi_info, &pAttr->roi_info, sizeof(TP_STREAM_ROI_S));
if(strm_id != STRM_ID_MAIN_SEC && strm_id != STRM_ID_MAIN_THD)
{
ret = hd_videoproc_start(g_video_avdc_stream[0][strm_id].proc_path);//direct模式vproc要比vcap早
if (ret != HD_OK && strm_id != STRM_ID_DLA) {
MPP_ERROR("hd_videoproc_start fail=%d\n", ret);
return -1;
}
}
#ifdef DLA_REC_STREAM_SUPPORT
// todo -- start STRM_ID_DLA_REC_STREAM 的vprc
if (g_strm_dla_rec_enabled == TRUE && strm_id == STRM_ID_DLA)
{
ret = hd_videoproc_start(g_video_avdc_stream[0][STRM_ID_DLA_REC].proc_path);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoproc_start fail=%d\n", ret);
return -1;
}
g_strm_param[0][STRM_ID_DLA_REC].video_stream_inited = TRUE;
MPP_ERROR("video stream STRM_ID_DLA_REC init finish");
// 由于JPEG vprc接入到 DLA_REC vprc的扩展通道，重启JPEG vprc
ret = hd_videoproc_stop(g_video_avdc_stream[0][STRM_ID_JPEG].proc_path);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoproc_stop fail=%d\n", ret);
return -1;
}
ret = hd_videoproc_start(g_video_avdc_stream[0][STRM_ID_JPEG].proc_path);
if (ret != HD_OK)
{
MPP_ERROR("hd_videoproc_stop fail=%d\n", ret);
return -1;
}
}
#endif
if(STRM_ID_MAIN == strm_id)
{
ret = hd_videoproc_start(g_video_avdc_stream[1][strm_id].proc_path);
if (ret != HD_OK && strm_id != STRM_ID_DLA) {
MPP_ERROR("hd_videoproc_start fail=%d\n", ret);
return -1;
}
ret = hd_videoproc_start(g_video_avdc_stream[0][0].avs_proc[0].proc_path_main);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_start avs[main] fail=%d\n", ret);
return -1;
}
if (pAttr->avs_out_res.res_w != AVS_OUT_DEF_W || pAttr->avs_out_res.res_h != AVS_OUT_DEF_H)
{
ret = hd_videoproc_start(g_video_avdc_stream[0][0].avs_proc[0].proc_path_scl_src);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_start scale[main] fail=%d\n", ret);
return -1;
}
}
#if SMART_STITCH
/* 非产测模式下启动动态拼接通道 */
if(!get_factory_mode() /* && g_is_smart_stitch_open == TRUE */)
{
ret = hd_videoproc_start(g_video_avdc_stream[0][0].avs_proc[0].proc_path_ss);
if (ret != HD_OK) {
MPP_ERROR("hd_videoproc_start avs[ss] fail=%d\n", ret);
return -1;
}
}
#endif
if (g_c_gain.gain[0] != 0 && g_c_gain.gain[1] != 0 && g_c_gain.gain[2] != 0)
{
g_c_gain.id = g_isp_id[0];
vendor_isp_set_common(ISPT_ITEM_C_GAIN, &g_c_gain);
g_c_gain.id = g_isp_id[1];
vendor_isp_set_common(ISPT_ITEM_C_GAIN, &g_c_gain);
if (get_hdr_cfg() == TP_VIDEO_HDR_ON)
{
g_c_gain.id = g_isp_id[0] + 1;
vendor_isp_set_common(ISPT_ITEM_C_GAIN, &g_c_gain);
g_c_gain.id = g_isp_id[1] + 1;
vendor_isp_set_common(ISPT_ITEM_C_GAIN, &g_c_gain);
}
}
// TODO -- 双目(均需要hdr)拼接：g_c_gain需要扩展为数组，下方设置的id，与实际使用的vcap id有关，
// 暂时还没确定，后续完善。当前已在avts中屏蔽hdr开启。-- 20240515 wangjunzhe
// TODO -- 预期：shdr sensor0为vcap0、3，sensor1为vcap1、4。
// 注: 开启shdr时，每个vap实际需要借用另一个vcap做长短帧融合。且sen0和sen1不能使用重复的vcap dev id。
/* ... ... */
ret = hd_videocap_start(g_video_avdc_stream[0][0].cap_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videocap_start 0 fail=%d\n", ret);
return -1;
}
ret = hd_videocap_start(g_video_avdc_stream[1][0].cap_path);
if (ret != HD_OK) {
MPP_ERROR("hd_videocap_start 1 fail=%d\n", ret);
return -1;
}
ret = set_cap_fps(g_video_avdc_stream[0][0].cap_ctrl);
if (ret != HD_OK) {
MPP_ERROR("set cap fps 0 fail=%d\n", ret);
return -1;
}
ret = set_cap_fps(g_video_avdc_stream[1][0].cap_ctrl);
if (ret != HD_OK) {
MPP_ERROR("set cap fps 1 fail=%d\n", ret);
return -1;
}
g_videocap_start = TRUE;
}
g_strm_param[0][strm_id].video_stream_inited = TRUE;
MPP_DEBUG("video stream [%d] init(for avs) finish", strm_id);
return OK;
}
#endif
这是双目机型的pipeline流程，这些关于aiisp的关键点应该嵌入到这个pipeline的哪些位置，有什么注意事项
本文介绍了S_OK、S_FALSE及E_FAIL这三个返回值的区别。S_OK和S_FALSE都表示成功，但S_FALSE提示方法未完全执行，不影响后续操作；而E_FAIL表示方法错误，需处理。
扫一扫
1624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
