bool HimppAencChan::enableObject()
{
HI_S32 s32Ret;
AENC_CHN_ATTR_S attr;
union {
AENC_ATTR_ADPCM_S adpcm;
AENC_ATTR_G711_S g711;
AENC_ATTR_G726_S g726;
AENC_ATTR_LPCM_S lpcm;
} enc_attr;
attr.u32BufSize = 30;
attr.pValue = &enc_attr;
switch (_encoding) {
case IAudioEncoder::ADPCM:
attr.enType = PT_ADPCMA;
enc_attr.adpcm.enADPCMType = AUDIO_ADPCM_TYPE;
break;
case IAudioEncoder::G711A:
attr.enType = PT_G711A;
enc_attr.g711.resv = 0;
break;
case IAudioEncoder::G711U:
attr.enType = PT_G711U;
enc_attr.g711.resv = 0;
break;
case IAudioEncoder::G726:
attr.enType = PT_G726;
enc_attr.g726.enG726bps = G726_BPS;
break;
case IAudioEncoder::LPCM:
attr.enType = PT_LPCM;
enc_attr.lpcm.resv = 0;
break;
}
s32Ret = HI_MPI_AENC_CreateChn(_chnid, &attr);
if (s32Ret != HI_SUCCESS) {
fprintf(stderr, "failed to create VENC chn%d\n", _chnid);
return false;
}
MPP_CHN_S dst_chn;
dst_chn.enModId = HI_ID_AENC;
dst_chn.s32DevId = 0;
dst_chn.s32ChnId = _chnid;
s32Ret = HI_MPI_SYS_Bind(*source(), &dst_chn);
if (s32Ret != HI_SUCCESS) {
fprintf(stderr, "HI_MPI_SYS_Bind AENC chn%d failed [%#x]\n",
_chnid, s32Ret);
goto err_destroy_chn;
}
return true;
err_destroy_chn:
HI_MPI_AENC_DestroyChn(_chnid);
return false;
}
HI_S32 HI_MPI_Sys_BindByForce(
HI_S32 DesTyp, HI_S32 DesGrp, HI_S32 DesChn,
HI_S32 SrcTyp, HI_S32 SrcGrp, HI_S32 SrcChn)
{
MPP_CHN_S stSrcChn,stDesChn;
stDesChn.enModId = DesTyp;
stDesChn.s32DevId = DesGrp;
stDesChn.s32ChnId = DesChn;
if(HI_SUCCESS == HI_MPI_SYS_GetBindbyDest(&stDesChn, &stSrcChn)) {
if(SrcTyp == stSrcChn.enModId
&& SrcGrp == stSrcChn.s32DevId
&& SrcChn == stSrcChn.s32ChnId) {
return HI_SUCCESS;
}
HI_MPI_SYS_UnBind(&stSrcChn, &stDesChn);
}
stSrcChn.enModId = SrcTyp;
stSrcChn.s32DevId = SrcGrp;
stSrcChn.s32ChnId = SrcChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDesChn);
}
/******************************************************************************
* function : Ao bind Adec
******************************************************************************/
HI_S32 SAMPLE_COMM_AUDIO_AoBindAdec(AUDIO_DEV AoDev, AO_CHN AoChn, ADEC_CHN AdChn)
{
MPP_CHN_S stSrcChn,stDestChn;
stSrcChn.enModId = HI_ID_ADEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = AdChn;
stDestChn.enModId = HI_ID_AO;
stDestChn.s32DevId = AoDev;
stDestChn.s32ChnId = AoChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
/******************************************************************************
* function : Ao bind Ai
******************************************************************************/
HI_S32 SAMPLE_COMM_AUDIO_AoBindAi(AUDIO_DEV AiDev, AI_CHN AiChn, AUDIO_DEV AoDev, AO_CHN AoChn)
{
MPP_CHN_S stSrcChn,stDestChn;
stSrcChn.enModId = HI_ID_AI;
stSrcChn.s32ChnId = AiChn;
stSrcChn.s32DevId = AiDev;
stDestChn.enModId = HI_ID_AO;
stDestChn.s32DevId = AoDev;
stDestChn.s32ChnId = AoChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
/******************************************************************************
* function : Aenc bind Ai
******************************************************************************/
HI_S32 SAMPLE_COMM_AUDIO_AencBindAi(AUDIO_DEV AiDev, AI_CHN AiChn, AENC_CHN AeChn)
{
MPP_CHN_S stSrcChn,stDestChn;
stSrcChn.enModId = HI_ID_AI;
stSrcChn.s32DevId = AiDev;
stSrcChn.s32ChnId = AiChn;
stDestChn.enModId = HI_ID_AENC;
stDestChn.s32DevId = 0;
stDestChn.s32ChnId = AeChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
HI_S32 SAMPLE_COMM_VO_BindVi(VO_LAYER VoLayer, VO_CHN VoChn, VI_CHN ViChn)
{
MPP_CHN_S stSrcChn, stDestChn;
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = ViChn;
stDestChn.enModId = HI_ID_VOU;
stDestChn.s32ChnId = VoChn;
stDestChn.s32DevId = VoLayer;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
static int enc_create_g711a_stream(int ain, int vin_ref, SDK_ENC_G711A_STREAM_ATTR_t* stream_attr)
{
if(ain < HI_AENC_CH_BACKLOG_REF){
if(vin_ref < HI_VENC_CH_BACKLOG_REF){
int const aenc_ch = ain;
SDK_ENC_G711A_STREAM_ATTR_t* const this_stream_attr = &_sdk_enc.attr.audio_stream_attr[ain];
if(0 == this_stream_attr->magic){
AENC_ATTR_G711_S aenc_attr_g711 = {0};
AENC_CHN_ATTR_S aenc_ch_attr = {.enType = PT_G711A, .pValue = &aenc_attr_g711,};
MPP_CHN_S mpp_ch_ai, mpp_ch_aenc;
aenc_ch_attr.enType = PT_G711A;
aenc_ch_attr.pValue = &aenc_attr_g711;
//aenc_ch_attr.u32BufSize = 8;
//aenc_ch_attr.u32BufSize = MAX_AUDIO_FRAME_NUM; // ver 050 faq 1.6.3
aenc_ch_attr.u32BufSize = MAX_AUDIO_FRAME_NUM;
memcpy(this_stream_attr, stream_attr, sizeof(SDK_ENC_G711A_STREAM_ATTR_t));
this_stream_attr->magic = ENC_H264_STREAM_ATTR_MAGIC; // mark the magic
this_stream_attr->ain = ain;
this_stream_attr->vin_ref = vin_ref;
// FIXME: remember to check the sample rate and bitwidth
this_stream_attr->sample_rate = SDK_ENC_AUDIO_SAMPLE_RATE_8KBPS;
this_stream_attr->bit_width = SDK_ENC_AUDIO_BITWIDTH_8BITS;
this_stream_attr->packet_size = 320;
// sdk operate
// enable vin
SOC_CHECK(HI_MPI_AI_EnableChn(__HI_AIN_CH, ain));
// create aenc chn
SOC_CHECK(HI_MPI_AENC_CreateChn(aenc_ch, &aenc_ch_attr));
#if 0 //enable resample
// bind AENC to AI channel
mpp_ch_ai.enModId = HI_ID_AI;
mpp_ch_ai.s32DevId = __HI_AIN_CH;
mpp_ch_ai.s32ChnId = ain;
mpp_ch_aenc.enModId = HI_ID_AENC;
mpp_ch_aenc.s32DevId = 0;
mpp_ch_aenc.s32ChnId = aenc_ch;
SOC_CHECK(HI_MPI_SYS_Bind(&mpp_ch_ai, &mpp_ch_aenc));
#endif
_sdk_enc.attr.audio_msk |= 1<<ain;
return SDK_SUCCESS;
}
}
HI_S32 HI_MPI_Vpss_BindVdec(HI_S32 VpssGrp, HI_S32 VdecChn)
{
MPP_CHN_S stSrcChn,stDesChn;
stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdecChn;
stDesChn.enModId = HI_ID_VPSS;
stDesChn.s32DevId = VpssGrp;
stDesChn.s32ChnId = 0;
return HI_MPI_SYS_Bind(&stSrcChn, &stDesChn);
}
HI_S32 HI_MPI_Ao_BindAi(AUDIO_DEV AoDev, AUDIO_DEV AiDev, AI_CHN AiChn)
{
MPP_CHN_S stSrcChn, stDesChn;
stSrcChn.enModId = HI_ID_AI;
stSrcChn.s32DevId = AiDev;
stSrcChn.s32ChnId = AiChn;
stDesChn.enModId = HI_ID_AO;
stDesChn.s32DevId = AoDev;
stDesChn.s32ChnId = 0;
return HI_MPI_SYS_Bind(&stSrcChn, &stDesChn);
}
HI_S32 SAMPLE_COMM_VO_BindVoWbc(VO_DEV VoWbcDev, VO_DEV VoDev, VO_CHN VoChn)
{
MPP_CHN_S stSrcChn, stDestChn;
stSrcChn.enModId = HI_ID_VOU;
stSrcChn.s32DevId = VoWbcDev;
stSrcChn.s32ChnId = 0;
stDestChn.enModId = HI_ID_VOU;
stDestChn.s32ChnId = VoChn;
stDestChn.s32DevId = VoDev;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
HI_S32 HI_MPI_VENC_BindVpss(VENC_GRP VeGroup, HI_S32 VpssGrp, HI_S32 VpssChn)
{
MPP_CHN_S stSrcChn,stDesChn;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = VpssGrp;
stSrcChn.s32ChnId = VpssChn;
stDesChn.enModId = HI_ID_GROUP;
stDesChn.s32DevId = VeGroup;
stDesChn.s32ChnId = 0;
return HI_MPI_SYS_Bind(&stSrcChn, &stDesChn);
}
HI_S32 HI_MPI_VO_BindVpss(HI_S32 VoGrp, HI_S32 VoChn, HI_S32 VpssGrp, HI_S32 VpssChn)
{
MPP_CHN_S stSrcChn,stDesChn;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = VpssGrp;
stSrcChn.s32ChnId = VpssChn;
stDesChn.enModId = HI_ID_VOU;
stDesChn.s32DevId = VoGrp;
stDesChn.s32ChnId = VoChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDesChn);
}
static int ao_bind_adec(AUDIO_DEV AoDev, AO_CHN AoChn, ADEC_CHN AdChn)
{
MPP_CHN_S stSrcChn;
memset(&stSrcChn, 0, sizeof(stSrcChn));
MPP_CHN_S stDestChn;
memset(&stDestChn, 0, sizeof(stDestChn));
stSrcChn.enModId = HI_ID_ADEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = AdChn;
stDestChn.enModId = HI_ID_AO;
stDestChn.s32DevId = AoDev;
stDestChn.s32ChnId = AoChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
static int aenc_bind_ai(AUDIO_DEV AiDev, AI_CHN AiChn, AENC_CHN AeChn)
{
MPP_CHN_S stSrcChn;
memset(&stSrcChn, 0, sizeof(stSrcChn));
MPP_CHN_S stDestChn;
memset(&stDestChn, 0, sizeof(stDestChn));
stSrcChn.enModId = HI_ID_AI;
stSrcChn.s32DevId = AiDev;
stSrcChn.s32ChnId = AiChn;
stDestChn.enModId = HI_ID_AENC;
stDestChn.s32DevId = 0;
stDestChn.s32ChnId = AeChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
}
bool HimppVpssGroup::enableObject()
{
HI_S32 s32Ret = HI_FAILURE;
ImageResolution res = videoSource()->getResolution();
VPSS_GRP_ATTR_S attr;
attr.u32MaxW = res.Width;
attr.u32MaxH = res.Height;
attr.bDciEn = HI_FALSE;
attr.bIeEn = HI_FALSE;
attr.bNrEn = HI_TRUE;
attr.bHistEn = HI_FALSE;
attr.enDieMode = VPSS_DIE_MODE_NODIE;
attr.enPixFmt = HIMPP_PIXEL_FORMAT;
if ((s32Ret = HI_MPI_VPSS_CreateGrp(_grpid, &attr)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VPSS_CreateGrp %d failed [%#x]\n",
_grpid, s32Ret);
return false;
}
if ((s32Ret = HI_MPI_VPSS_StartGrp(_grpid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VPSS_CreateGrp %d failed [%#x]\n",
_grpid, s32Ret);
goto err_destroy_grp;
}
MPP_CHN_S dst_chn;
dst_chn.enModId = HI_ID_VPSS;
dst_chn.s32DevId = _grpid;
dst_chn.s32ChnId = 0;
if ((s32Ret = HI_MPI_SYS_Bind(*source(), &dst_chn)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_SYS_Bind %d failed [%#x]\n",
_grpid, s32Ret);
goto err_stop_grp;
}
return true;
err_stop_grp:
HI_MPI_VPSS_StopGrp(_grpid);
err_destroy_grp:
HI_MPI_VPSS_DestroyGrp(_grpid);
return false;
}
HI_S32 HI_MPI_Ao_BindAiByForce(AUDIO_DEV AoDev, AUDIO_DEV AiDev, AI_CHN AiChn)
{
MPP_CHN_S stSrcChn, stDesChn;
memset(&stSrcChn, 0, sizeof(stSrcChn));
stDesChn.enModId = HI_ID_AO;
stDesChn.s32DevId = AoDev;
stDesChn.s32ChnId = 0;
if(!HI_MPI_SYS_GetBindbyDest(&stDesChn, &stSrcChn)) {
HI_MPI_SYS_UnBind(&stSrcChn, &stDesChn);
}
stSrcChn.enModId = HI_ID_AI;
stSrcChn.s32DevId = AiDev;
stSrcChn.s32ChnId = AiChn;
return HI_MPI_SYS_Bind(&stSrcChn, &stDesChn);
}
/*****************************************************************************
* function : Vi chn bind vpss group
*****************************************************************************/
HI_S32 SAMPLE_COMM_VI_BindVpss(SAMPLE_VI_MODE_E enViMode)
{
HI_S32 j, s32Ret;
VPSS_GRP VpssGrp;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
SAMPLE_VI_PARAM_S stViParam;
VI_CHN ViChn;
s32Ret = SAMPLE_COMM_VI_Mode2Param(enViMode, &stViParam);
if (HI_SUCCESS !=s32Ret)
{
SAMPLE_PRT("SAMPLE_COMM_VI_Mode2Param failed!\n");
return HI_FAILURE;
}
VpssGrp = 0;
for (j=0; j<stViParam.s32ViChnCnt; j++)
{
ViChn = j * stViParam.s32ViChnInterval;
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = ViChn;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = VpssGrp;
stDestChn.s32ChnId = 0;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
VpssGrp ++;
}
return HI_SUCCESS;
}
HI_S32 SAMPLE_COMM_VO_BindVpss(VO_DEV VoDev,VO_CHN VoChn,VPSS_GRP VpssGrp,VPSS_CHN VpssChn)
{
HI_S32 s32Ret = HI_SUCCESS;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = VpssGrp;
stSrcChn.s32ChnId = VpssChn;
stDestChn.enModId = HI_ID_VOU;
stDestChn.s32DevId = VoDev;
stDestChn.s32ChnId = VoChn;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
return s32Ret;
}
/******************************************************************************
* function : vdec bind venc
******************************************************************************/
HI_S32 SAMPLE_COMM_VDEC_BindVenc(VDEC_CHN VdChn,VENC_CHN VeChn)
{
HI_S32 s32Ret = HI_SUCCESS;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;
stDestChn.enModId = HI_ID_VENC;
stDestChn.s32DevId = 0;
stDestChn.s32ChnId = VeChn;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
return s32Ret;
}
/******************************************************************************
* function : vdec group bind vpss chn
******************************************************************************/
HI_S32 SAMLE_COMM_VDEC_BindVpss(VDEC_CHN VdChn, VPSS_GRP VpssGrp)
{
HI_S32 s32Ret = HI_SUCCESS;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;
stDestChn.enModId = HI_ID_VPSS;
stDestChn.s32DevId = VpssGrp;
stDestChn.s32ChnId = 0;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_SYS_Bind failed with %#x!\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
/******************************************************************************
* function : vdec group bind vo chn
******************************************************************************/
HI_S32 SAMLE_COMM_VDEC_BindVo(VDEC_CHN VdChn, VO_DEV VoDev, VO_CHN VoChn)
{
HI_S32 s32Ret = HI_SUCCESS;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
stSrcChn.enModId = HI_ID_VDEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = VdChn;
stDestChn.enModId = HI_ID_VOU;
stDestChn.s32DevId = VoDev;
stDestChn.s32ChnId = VoChn;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("HI_MPI_SYS_Bind failed with %#x!\n",s32Ret);
return HI_FAILURE;
}
return HI_SUCCESS;
}
bool HimppVencChan::enableObject()
{
HI_S32 s32Ret;
GROUP_CROP_CFG_S dis_crop = { .bEnable = HI_FALSE };
if ((s32Ret = HI_MPI_VENC_CreateGroup(_grpid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_CreateGroup %d failed [%#x]\n",
_grpid, s32Ret);
return false;
}
VENC_CHN_ATTR_S attr;
prepareVencChnAttr(attr);
if ((s32Ret = HI_MPI_VENC_CreateChn(_chnid, &attr)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_CreateChn %d faild [%#x]\n",
_chnid, s32Ret);
goto err_destroy_grp;
}
if ((s32Ret = HI_MPI_VENC_SetMaxStreamCnt(_chnid, 4)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_SetMaxStreamCnt %d failed [%#x]\n",
_chnid, s32Ret);
}
if ((s32Ret = HI_MPI_VENC_RegisterChn(_grpid, _chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_RegisterChn %d-%d failed [%#x]\n",
_grpid, _chnid, s32Ret);
goto err_destroy_chn;
}
if ((s32Ret = HI_MPI_VENC_SetGrpCrop(_grpid, &_crop_cfg)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_SetGrpCrop [%d] faild [%#x]!\n",
_grpid, s32Ret);
goto err_unregister_chn;
}
if ((s32Ret = HI_MPI_VENC_StartRecvPic(_chnid)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_VENC_StartRecvPic %d failed [%#x]\n",
_chnid, s32Ret);
goto err_disable_crop;
}
MPP_CHN_S dst_chn;
dst_chn.enModId = HI_ID_GROUP;
dst_chn.s32DevId = _grpid;
dst_chn.s32ChnId = 0;
if ((s32Ret = HI_MPI_SYS_Bind(*source(), &dst_chn)) != HI_SUCCESS) {
HIMPP_PRINT("HI_MPI_SYS_Bind %d failed [%#x]\n",
_chnid, s32Ret);
goto err_stop_recv_pic;
}
return true;
err_stop_recv_pic:
HI_MPI_VENC_StopRecvPic(_chnid);
err_disable_crop:
HI_MPI_VENC_SetGrpCrop(_grpid, &dis_crop);
err_unregister_chn:
HI_MPI_VENC_UnRegisterChn(_chnid);
err_destroy_chn:
HI_MPI_VENC_DestroyChn(_chnid);
err_destroy_grp:
HI_MPI_VENC_DestroyGroup(_grpid);
return false;
}
/******************************************************************************
* funciton : bind venc and vpss.
******************************************************************************/
HI_S32 venc_bind_vpss(VENC_CHN VencChn, SIZE_S *stSize, HI_BOOL Bind)
{
HI_S32 s32Ret;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
VPSS_CHN_MODE_S stVpssChnMode;
// VENC_GRP VencGrp = VencChn;
VPSS_GRP VpssGrp = VencChn;
VPSS_CHN VpssChn = 1;
stSrcChn.enModId = HI_ID_VPSS;
stSrcChn.s32DevId = VpssGrp;
stSrcChn.s32ChnId = VpssChn;
stDestChn.enModId = HI_ID_VENC;
stDestChn.s32DevId = 0;
stDestChn.s32ChnId = VencChn;
if(Bind == HI_TRUE)
{
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
Printf("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVpssChnMode.u32Width = stSize->u32Width;
stVpssChnMode.u32Height = stSize->u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, &stVpssChnMode);
if (HI_SUCCESS != s32Ret)
{
Printf("set vpss grp%d chn%d mode fail, s32Ret: 0x%x.\n", VpssGrp, VpssChn, s32Ret);
return s32Ret;
}
}
else
{
s32Ret = HI_MPI_SYS_UnBind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
Printf("failed with %#x!\n", s32Ret);
return HI_FAILURE;
}
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_AUTO;
stVpssChnMode.enPixelFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stVpssChnMode.u32Width = stSize->u32Width;
stVpssChnMode.u32Height = stSize->u32Height;
stVpssChnMode.enCompressMode = COMPRESS_MODE_NONE;
s32Ret = HI_MPI_VPSS_SetChnMode(VpssGrp, VpssChn, &stVpssChnMode);
if (HI_SUCCESS != s32Ret)
{
Printf("set vpss grp%d chn%d mode fail, s32Ret: 0x%x.\n", VpssGrp, VpssChn, s32Ret);
return s32Ret;
}
}
return HI_SUCCESS;
}
int main(int argc, char const *argv[])
{
PAYLOAD_TYPE_E enPayLoad = PT_H264;
VB_CONF_S stVbConf;
SAMPLE_VI_CONFIG_S stViConfig;
VPSS_GRP_ATTR_S stVpssGrpAttr;
VPSS_CHN_ATTR_S stVpssChnAttr;
VPSS_CHN_MODE_S stVpssChnMode;
VI_EXT_CHN_ATTR_S stExtChnAttr;
SAMPLE_RC_E enRcMode = SAMPLE_RC_CBR;
HI_S32 s32ChnNum = 1;
HI_S32 s32Ret = HI_SUCCESS;
HI_U32 u32BlkSize;
SIZE_S stSize;
int sockfd, SendSockfd;
struct sockaddr_in SendServaddr;
pthread_t sendvideotid, AnalyzePictid, snaptid, accepttid;
int ret;
MPP_CHN_S stSrcChn;
MPP_CHN_S stDestChn;
memset(&stVbConf, 0 , sizeof(VB_CONF_S));
stVbConf.u32MaxPoolCnt = 128;
u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,
enSize, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
stVbConf.astCommPool[0].u32BlkCnt = 10;
// u32BlkSize = SAMPLE_COMM_SYS_CalcPicVbBlkSize(gs_enNorm,
// PIC_QVGA, SAMPLE_PIXEL_FORMAT, SAMPLE_SYS_ALIGN_WIDTH);
// stVbConf.astCommPool[0].u32BlkSize = u32BlkSize;
// stVbConf.astCommPool[0].u32BlkCnt = 10;
//初始化系统
printf("-----------------------V0.01-----------------------\n");
s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
printf("system init failed with err code %#x!\n", s32Ret );
}
stViConfig.enViMode = SENSOR_TYPE;
//stViConfig.enViMode = SONY_IMX122_DC_1080P_30FPS;
stViConfig.enRotate = ROTATE_NONE;
stViConfig.enNorm = VIDEO_ENCODING_MODE_AUTO;
stViConfig.enViChnSet = VI_CHN_SET_NORMAL;
//配置并启动VI
s32Ret = SAMPLE_COMM_VI_StartVi(&stViConfig);
if (HI_SUCCESS != s32Ret)
{
printf("start vi failed with err code %#x!\n", s32Ret);
goto END_1;
}
stExtChnAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stExtChnAttr.s32BindChn = ViChn;
stExtChnAttr.stDestSize.u32Width = WIDTH;
stExtChnAttr.stDestSize.u32Height = HEIGHT;
stExtChnAttr.s32FrameRate = -1;
stExtChnAttr.s32SrcFrameRate = -1;
s32Ret = HI_MPI_VI_SetExtChnAttr(ExtChn, &stExtChnAttr);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VI_SetExtChnAttr failed with err code %#x\n", s32Ret);
return -1;
}
s32Ret = HI_MPI_VI_SetFrameDepth(1, 5);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VI_SetFrameDepth failed with err code %#x\n", s32Ret);
return -1;
}
s32Ret = HI_MPI_VI_EnableChn(ExtChn);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VI_EnableChn failed with err code %#x\n", s32Ret);
return -1;
}
stExtChnAttr.enPixFormat = PIXEL_FORMAT_YUV_SEMIPLANAR_420;
stExtChnAttr.s32BindChn = ViChn;
stExtChnAttr.stDestSize.u32Width = WIDTH;
stExtChnAttr.stDestSize.u32Height = HEIGHT;
stExtChnAttr.s32FrameRate = -1;
stExtChnAttr.s32SrcFrameRate = -1;
s32Ret = HI_MPI_VI_SetExtChnAttr(SnapExtChn, &stExtChnAttr);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VI_SetExtChnAttr failed with err code %#x\n", s32Ret);
return -1;
}
s32Ret = HI_MPI_VI_EnableChn(SnapExtChn);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VI_EnableChn failed with err code %#x\n", s32Ret);
return -1;
}
#if 1
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize, &stSize);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_SYS_GetPicSize failed with err code %#x!\n", s32Ret);
goto END_2;
}
//配置并启动VPSS组
stVpssGrpAttr.u32MaxW = stSize.u32Width;
stVpssGrpAttr.u32MaxH = stSize.u32Height;
stVpssGrpAttr.bDrEn = HI_FALSE;
stVpssGrpAttr.bDbEn = HI_FALSE;
stVpssGrpAttr.bIeEn = HI_TRUE;
stVpssGrpAttr.bNrEn = HI_TRUE;
stVpssGrpAttr.bHistEn = HI_TRUE;
stVpssGrpAttr.enDieMode = VPSS_DIE_MODE_AUTO;
stVpssGrpAttr.enPixFmt = SAMPLE_PIXEL_FORMAT;
s32Ret = SAMPLE_COMM_VPSS_StartGroup(VpssGrp, &stVpssGrpAttr);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_VPSS_StartGroup failed with err code %#x!\n", s32Ret);
goto END_3;
}
//绑定VI和VPSS
s32Ret = SAMPLE_COMM_VI_BindVpss(stViConfig.enViMode);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_vi_BindVpss failed with err code %#x\n", s32Ret);
goto END_4;
}
//配置并启动VPSS通道
memset(&stVpssChnAttr, 0, sizeof(stVpssChnAttr));
stVpssChnAttr.bFrameEn = HI_FALSE;
stVpssChnAttr.bSpEn = HI_TRUE;
stVpssChnMode.enChnMode = VPSS_CHN_MODE_USER;
stVpssChnMode.bDouble = HI_FALSE;
stVpssChnMode.enPixelFormat = SAMPLE_PIXEL_FORMAT;
stVpssChnMode.u32Width = 1920;
stVpssChnMode.u32Height = 1080;
s32Ret = SAMPLE_COMM_VPSS_EnableChn(VpssGrp, VpssChn, &stVpssChnAttr, &stVpssChnMode, HI_NULL);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_VPSS_EnableChn failed with err code %#x\n", s32Ret);
goto END_5;
}
#if 0
s32Ret = SAMPLE_COMM_VENC_BindVpss(SnapVencGrp, VpssGrp, VpssChn);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_VENC_BindVpss failed with err code %#x\n", s32Ret);
}
gs_enNorm = PIC_D1;
s32Ret = SAMPLE_COMM_SYS_GetPicSize(gs_enNorm, enSize, &stSize);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_SYS_GetPicSize failed with err code %#x\n", s32Ret);
}
#endif
#endif
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = SnapExtChn;
stDestChn.enModId = HI_ID_GROUP;
stDestChn.s32DevId = SnapVencGrp;
stDestChn.s32ChnId = 0;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if (s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("failed with %#x!\n", s32Ret);
//return HI_FAILURE;
}
stSize.u32Width = 720;
stSize.u32Height = 576;
//printf("%d,%d\n",stSize.u32Width,stSize.u32Height);
s32Ret = SAMPLE_COMM_VENC_SnapStart(SnapVencGrp, SnapVencChn, &stSize);
if (HI_SUCCESS != s32Ret)
{
printf("SAMPLE_COMM_VENC_SnapStart failed with err code %#x\n", s32Ret);
}
#if 1
#if 0
//创建发送视频流socket
//SendSockfd = socket(AF_INET, SOCK_STREAM, 0);
SendSockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (SendSockfd == -1)
{
perror("send socket error");
exit(0);
}
memset(&SendServaddr, 0, sizeof(SendServaddr));
SendServaddr.sin_family = AF_INET;
//SendServaddr.sin_addr.s_addr = htonl(INADDR_ANY);
SendServaddr.sin_addr.s_addr = inet_addr("10.1.2.60");
SendServaddr.sin_port = htons(6666);
#endif
#if 0
if (bind(SendSockfd, (struct sockaddr *)&SendServaddr, sizeof(SendServaddr)) == -1)
{
perror("send bind error");
exit(0);
}
if (listen(SendSockfd, 10) == -1)
{
perror("send listen error");
exit(0);
}
#endif
#if 0
//ret = pthread_create(&sendvideotid, 0, (HI_VOID*)SendVideoStream, SendSockfd);
ret = pthread_create(&sendvideotid, 0, (HI_VOID*)SendVideoStream, 0);
if (ret != 0)
{
perror("create SendVideoStream error");
exit(0);
}
printf("create SendVideoStream thread successfully!\n");
#endif
#endif
ret = pthread_create(&AnalyzePictid, 0, (HI_VOID*)AnalyzePic, NULL);
if (ret != 0)
{
perror("create AnalyzePic error");
exit(0);
}
ret = pthread_create(&snaptid, 0, (HI_VOID*)SnapPic, NULL);
if (ret != 0)
{
perror("create SnapPic error");
exit(0);
}
ret = pthread_create(&accepttid, 0, (HI_VOID*)accept_thread, NULL);
if (ret != 0)
{
perror("create accept_thread error");
exit(0);
}
while (1)
{
sleep(10);
}
END_5:
SAMPLE_COMM_VPSS_DisableChn(VpssGrp, VpssChn);
END_4:
SAMPLE_COMM_VI_UnBindVpss(stViConfig.enViMode);
END_3:
SAMPLE_COMM_VPSS_StopGroup(VpssGrp);
END_2:
SAMPLE_COMM_VI_StopVi(&stViConfig);
END_1:
SAMPLE_COMM_SYS_Exit();
close(SendSockfd);
pthread_join(sendvideotid, NULL);
return 0;
}
/******************************************************************************
* funciton : start vda MD mode
******************************************************************************/
HI_S32 SAMPLE_COMM_VDA_MdStart(VDA_CHN VdaChn, VI_CHN ViChn, SIZE_S *pstSize)
{
HI_S32 s32Ret = HI_SUCCESS;
VDA_CHN_ATTR_S stVdaChnAttr;
MPP_CHN_S stSrcChn, stDestChn;
if (VDA_MAX_WIDTH < pstSize->u32Width || VDA_MAX_HEIGHT < pstSize->u32Height)
{
SAMPLE_PRT("Picture size invaild!\n");
return HI_FAILURE;
}
/* step 1 create vda channel */
stVdaChnAttr.enWorkMode = VDA_WORK_MODE_MD;
stVdaChnAttr.u32Width = pstSize->u32Width;
stVdaChnAttr.u32Height = pstSize->u32Height;
stVdaChnAttr.unAttr.stMdAttr.enVdaAlg = VDA_ALG_REF;
stVdaChnAttr.unAttr.stMdAttr.enMbSize = VDA_MB_16PIXEL;
stVdaChnAttr.unAttr.stMdAttr.enMbSadBits = VDA_MB_SAD_8BIT;
stVdaChnAttr.unAttr.stMdAttr.enRefMode = VDA_REF_MODE_DYNAMIC;
stVdaChnAttr.unAttr.stMdAttr.u32MdBufNum = 8;
stVdaChnAttr.unAttr.stMdAttr.u32VdaIntvl = 4;
stVdaChnAttr.unAttr.stMdAttr.u32BgUpSrcWgt = 128;
stVdaChnAttr.unAttr.stMdAttr.u32SadTh = 100;
stVdaChnAttr.unAttr.stMdAttr.u32ObjNumMax = 128;
s32Ret = HI_MPI_VDA_CreateChn(VdaChn, &stVdaChnAttr);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err!\n");
return s32Ret;
}
/* step 2: vda chn bind vi chn */
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32ChnId = ViChn;
stSrcChn.s32DevId = 0;
stDestChn.enModId = HI_ID_VDA;
stDestChn.s32ChnId = VdaChn;
stDestChn.s32DevId = 0;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err!\n");
return s32Ret;
}
/* step 3: vda chn start recv picture */
s32Ret = HI_MPI_VDA_StartRecvPic(VdaChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err!\n");
return s32Ret;
}
/* step 4: create thread to get result */
gs_stMdParam.bThreadStart = HI_TRUE;
gs_stMdParam.VdaChn = VdaChn;
pthread_create(&gs_VdaPid[SAMPLE_VDA_MD_CHN],0, SAMPLE_COMM_VDA_MdGetResult, (HI_VOID *)&gs_stMdParam);
return HI_SUCCESS;
}
/******************************************************************************
* funciton : start vda OD mode
******************************************************************************/
HI_S32 SAMPLE_COMM_VDA_OdStart(VDA_CHN VdaChn, VI_CHN ViChn, SIZE_S *pstSize)
{
VDA_CHN_ATTR_S stVdaChnAttr;
MPP_CHN_S stSrcChn, stDestChn;
HI_S32 s32Ret = HI_SUCCESS;
if (VDA_MAX_WIDTH < pstSize->u32Width || VDA_MAX_HEIGHT < pstSize->u32Height)
{
SAMPLE_PRT("Picture size invaild!\n");
return HI_FAILURE;
}
/********************************************
step 1 : create vda channel
********************************************/
stVdaChnAttr.enWorkMode = VDA_WORK_MODE_OD;
stVdaChnAttr.u32Width = 640;//pstSize->u32Width;
stVdaChnAttr.u32Height = 480;//pstSize->u32Height;
stVdaChnAttr.unAttr.stOdAttr.enVdaAlg = VDA_ALG_BG;
stVdaChnAttr.unAttr.stOdAttr.enMbSize = VDA_MB_16PIXEL;
stVdaChnAttr.unAttr.stOdAttr.enMbSadBits = VDA_MB_SAD_16BIT;
stVdaChnAttr.unAttr.stOdAttr.enRefMode = VDA_REF_MODE_DYNAMIC;
stVdaChnAttr.unAttr.stOdAttr.u32VdaIntvl = 4;
stVdaChnAttr.unAttr.stOdAttr.u32BgUpSrcWgt = 1;
stVdaChnAttr.unAttr.stOdAttr.u32RgnNum = 1;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].stRect.s32X = 0;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].stRect.s32Y = 0;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].stRect.u32Width = 320;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].stRect.u32Height = 64;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].u32SadTh = 100;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].u32AreaTh = 70;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].u32OccCntTh = 1;
stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[0].u32UnOccCntTh = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.s32X = 320;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.s32Y = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.u32Width = 320;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.u32Height = 64;
//
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32SadTh = 100;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32AreaTh = 40;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32OccCntTh = 1;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32UnOccCntTh = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].stRect.s32X = 320;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].stRect.s32Y = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].stRect.u32Width = 160;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].stRect.u32Height = 64;
//
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].u32SadTh = 100;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].u32AreaTh = 40;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].u32OccCntTh = 1;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[2].u32UnOccCntTh = 0;
//
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].stRect.s32X = 480;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].stRect.s32Y = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].stRect.u32Width = 160;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].stRect.u32Height = 64;
//
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].u32SadTh = 100;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].u32AreaTh = 40;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].u32OccCntTh = 1;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[3].u32UnOccCntTh = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.s32X = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.s32Y = 0;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.u32Width = pstSize->u32Width;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].stRect.u32Height = pstSize->u32Height;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32SadTh = 100;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32AreaTh = 60;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32OccCntTh = 6;
// stVdaChnAttr.unAttr.stOdAttr.astOdRgnAttr[1].u32UnOccCntTh = 2;
s32Ret = HI_MPI_VDA_CreateChn(VdaChn, &stVdaChnAttr);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err! 0x%x\n", s32Ret);
return(s32Ret);
}
/********************************************
step 2 : bind vda channel to vi channel
********************************************/
/* vda start rcv picture */
s32Ret = HI_MPI_VDA_StartRecvPic(VdaChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err!\n");
return(s32Ret);
}
//Send_Picture(VdaChn, "./background.yuv");
stSrcChn.enModId = HI_ID_VIU;
stSrcChn.s32ChnId = ViChn;
stDestChn.enModId = HI_ID_VDA;
stDestChn.s32ChnId = VdaChn;
stDestChn.s32DevId = 0;
s32Ret = HI_MPI_SYS_Bind(&stSrcChn, &stDestChn);
if(s32Ret != HI_SUCCESS)
{
SAMPLE_PRT("err!\n");
return s32Ret;
}
// s32Ret = HI_MPI_VDA_StartRecvPic(VdaChn);
// if(s32Ret != HI_SUCCESS)
// {
// SAMPLE_PRT("err!\n");
// return(s32Ret);
// }
gs_stOdParam.bThreadStart = HI_TRUE;
gs_stOdParam.VdaChn = VdaChn;
pthread_create(&gs_VdaPid[SAMPLE_VDA_OD_CHN], 0, SAMPLE_COMM_VDA_OdGetResult, (HI_VOID *)&gs_stOdParam);
return HI_SUCCESS;
}
int adec_ao (AIO_ATTR_S *pstAioAttr)
{
HI_S32 sret;
int ret = FAILURE;
AUDIO_DEV aoDev = 0;
AO_CHN aoChn = 0;
ADEC_CHN adChn = 0;
int acodec_fd = 0;
unsigned int i2s_fs_sel = 0;
//-----------Set CFG-------------
acodec_fd = open (ACODEC_FILE,O_RDWR);
if (acodec_fd < 0)
{
printf ("open[%s] error[%s]\n", ACODEC_FILE, strerror (errno));
return ret;
}
if (ioctl (acodec_fd, ACODEC_SOFT_RESET_CTRL))
{
printf ("reset codec error\n");
return ret;
}
i2s_fs_sel = 0x18;//AUDIO_SAMPLE_RATE_8000
if (ioctl (acodec_fd, ACODEC_SET_I2S1_FS,&i2s_fs_sel))
{
printf ("set acodec sample rate failure\n");
return ret;
}
close (acodec_fd);
//-------------Start Adec-------------
ADEC_CHN_ATTR_S stAdecAttr;
stAdecAttr.enType = PT_G711A;
stAdecAttr.u32BufSize = 20;
stAdecAttr.enMode = ADEC_MODE_STREAM;
if (PT_ADPCMA == stAdecAttr.enType)
{
ADEC_ATTR_ADPCM_S stAdpcm;
stAdecAttr.pValue = &stAdpcm;
stAdpcm.enADPCMType = 0;
printf ("-----------I do not Play Pcm\n");
}
else if (PT_G711A == stAdecAttr.enType || PT_G711U == stAdecAttr.enType)
{
ADEC_ATTR_G711_S stAdecG711;
stAdecAttr.pValue = &stAdecG711;
}
else
{
printf ("Undefine Type\n");
return ret;
}
sret = HI_MPI_ADEC_CreateChn(adChn, &stAdecAttr);
if (sret != HI_SUCCESS)
{
printf ("HI_MPI_ADEC_CreateChn error[%x]\n", sret);
return ret;
}
//----------------------Start Ao-----------
sret = HI_MPI_AO_SetPubAttr (aoDev, pstAioAttr);
if (sret != SUCCESS)
{
printf ("HI_MPI_AO_SetPubAttr error[%x]\n", sret);
return ret;
}
sret = HI_MPI_AO_Enable (aoDev);
if (sret != SUCCESS)
{
printf ("HI_MPI_AO_Enable error[%x]\n", sret);
return ret;
}
sret = HI_MPI_AO_EnableChn (aoDev, aoChn);
if (sret != SUCCESS)
{
printf ("HI_MPI_AO_EnableChn error[%x]\n", sret);
return ret;
}
//-------- SAMPLE_COMM_AUDIO_AoBindAdec
MPP_CHN_S stSrcChn,stDestChn;
stSrcChn.enModId = HI_ID_ADEC;
stSrcChn.s32DevId = 0;
stSrcChn.s32ChnId = adChn;
stDestChn.enModId = HI_ID_AO;
stDestChn.s32DevId = aoDev;
stDestChn.s32ChnId = aoChn;
sret = HI_MPI_SYS_Bind (&stSrcChn, &stDestChn);
if (sret != HI_SUCCESS)
{
printf ("HI_MPI_SYS_Bind error [%x]\n", sret);
return ret;
}
printf ("HI_MPI_SYS_Bind success\n");
//--------------SAMPLE_COMM_AUDIO_AdecProc
int AdChn = adChn;
FILE *pfd = NULL;
AUDIO_STREAM_S stAudioStream;
HI_U32 u32Len = 324;
HI_U32 u32ReadLen;
HI_S32 s32AdecChn = AdChn;
HI_U8 *pu8AudioStream = NULL;
pfd = fopen ("/root/ap_down.voice", "r");
if (pfd == NULL)
{
printf ("open file error[%s]\n", strerror (errno));
return -1;
}
printf ("open file success\n");
pu8AudioStream = (HI_U8*)malloc(sizeof(HI_U8)*MAX_AUDIO_STREAM_LEN);
while (1)
{
stAudioStream.pStream = pu8AudioStream;
u32ReadLen = fread(stAudioStream.pStream, 1, u32Len, pfd/*文件FD*/);
if (u32ReadLen <= 0)
{
printf ("read complete\n");
break;
}
stAudioStream.u32Len = u32ReadLen;
sret = HI_MPI_ADEC_SendStream(s32AdecChn, &stAudioStream, HI_TRUE);
if (sret != HI_SUCCESS)
{
printf ("HI_MPI_ADEC_SendStream error [%x]\n", sret);
break;
}
}
free(pu8AudioStream);
fclose(pfd);
printf ("Wow, it ok\n");
return 0;
}
static int enc_create_h264_stream(const char* name, int vin, int stream, SDK_ENC_H264_STREAM_ATTR_t* stream_attr)
{
if(stream_attr && vin < HI_VENC_CH_BACKLOG_REF && stream < HI_VENC_STREAM_BACKLOG_REF){
SDK_ENC_H264_STREAM_ATTR_t* this_stream_attr = &_sdk_enc.attr.video_stream_attr[vin][stream];
if(0 == this_stream_attr->magic){
int const venc_group = vin * HI_VENC_STREAM_BACKLOG_REF + stream;
int const venc_ch = venc_group;
int const vpss_group = vin;
int const vpss_ch = (0 == stream) ? VPSS_BSTR_CHN : VPSS_LSTR_CHN;
int bps_regular = 0;
// hisilicon structure
//VPSS_CHN_MODE_S vpss_chn_mode;
//VPSS_CHN_ATTR_S vpss_chn_attr;
MPP_CHN_S mpp_chn_vpss;
MPP_CHN_S mpp_chn_venc;
VENC_CHN_ATTR_S venc_chn_attr;
VENC_ATTR_H264_REF_MODE_E venc_attr_h264_ref_mode;
VENC_ATTR_S* const p_venc_attr = &venc_chn_attr.stVeAttr; // the attribute of video encoder
VENC_RC_ATTR_S* const p_venc_rc_attr = &venc_chn_attr.stRcAttr; // the attribute of rate ctrl
VENC_ATTR_H264_S* const p_venc_attr_h264 = &p_venc_attr->stAttrH264e;
VENC_ATTR_H264_CBR_S* const p_h264_cbr = &p_venc_rc_attr->stAttrH264Cbr;
VENC_ATTR_H264_VBR_S* const p_h264_vbr = &p_venc_rc_attr->stAttrH264Vbr;
VENC_ATTR_H264_FIXQP_S* const p_h264_fixqp = &p_venc_rc_attr->stAttrH264FixQp;
VENC_ATTR_H264_ABR_S* const p_h264_abr = &p_venc_rc_attr->stAttrH264Abr;
// only magic is null could be init
// init this stream attribute;
memcpy(this_stream_attr, stream_attr, sizeof(SDK_ENC_H264_STREAM_ATTR_t));
strncpy(this_stream_attr->name, name, sizeof(this_stream_attr->name));
this_stream_attr->magic = ENC_H264_STREAM_ATTR_MAGIC;
this_stream_attr->vin = vin;
this_stream_attr->stream = stream;
this_stream_attr->start = false; // very important, declare the encode status
// Greate Venc Group
SOC_CHECK(HI_MPI_VENC_CreateGroup(venc_group));
// Create Venc Channel
memset(&venc_chn_attr, 0, sizeof(venc_chn_attr));
p_venc_attr->enType = PT_H264; // must be h264 for this interface
p_venc_attr_h264->u32MaxPicWidth = stream_attr->width;
p_venc_attr_h264->u32MaxPicHeight = stream_attr->height;
p_venc_attr_h264->u32PicWidth = stream_attr->width; // the picture width
p_venc_attr_h264->u32PicHeight = stream_attr->height;// the picture height
//p_venc_attr_h264->u32BufSize = p_venc_attr_h264->u32MaxPicWidth * p_venc_attr_h264->u32MaxPicHeight * 3 / 2; // stream buffer size
p_venc_attr_h264->u32BufSize = p_venc_attr_h264->u32MaxPicWidth * p_venc_attr_h264->u32MaxPicHeight*3/4; // stream buffer size
if(0 < (p_venc_attr_h264->u32BufSize%64)) {
p_venc_attr_h264->u32BufSize += 64 - (p_venc_attr_h264->u32BufSize%64);
}
switch(stream_attr->profile){
default:
case SDK_ENC_H264_PROFILE_BASELINE:
p_venc_attr_h264->u32Profile = 0;
break;
case SDK_ENC_H264_PROFILE_DEFAULT:
case SDK_ENC_H264_PROFILE_MAIN:
p_venc_attr_h264->u32Profile = 1;
break;
}
p_venc_attr_h264->bByFrame = HI_TRUE;// get stream mode is slice mode or frame mode
p_venc_attr_h264->bField = HI_FALSE; // surpport frame code only for hi3516, bfield = HI_FALSE
p_venc_attr_h264->bMainStream = HI_TRUE; // surpport main stream only for hi3516, bMainStream = HI_TRUE
p_venc_attr_h264->u32Priority = 0; // channels precedence level. invalidate for hi3516
p_venc_attr_h264->bVIField = HI_FALSE; // the sign of the VI picture is field or frame. Invalidate for hi3516
switch(stream_attr->profile){
case SDK_ENC_H264_PROFILE_BASELINE:
{
p_venc_attr_h264->u32Profile = 0;
break;
}
case SDK_ENC_H264_PROFILE_DEFAULT:
case SDK_ENC_H264_PROFILE_MAIN:
{
p_venc_attr_h264->u32Profile = 1;
break;
}
}
bps_regular = bitrate_regulate(this_stream_attr->width, this_stream_attr->height, this_stream_attr->bps);
switch(stream_attr->mode){
case SDK_ENC_H264_MODE_VBR:
case SDK_ENC_H264_MODE_AUTO:
{
venc_chn_attr.stRcAttr.enRcMode = VENC_RC_MODE_H264VBRv2;
p_h264_vbr->u32Gop = stream_attr->gop;
p_h264_vbr->u32StatTime = (stream_attr->gop + stream_attr->fps - 1) / stream_attr->fps;
p_h264_vbr->u32ViFrmRate = stream_attr->vin_fps;
p_h264_vbr->fr32TargetFrmRate = (typeof(p_h264_vbr->fr32TargetFrmRate))stream_attr->fps;
p_h264_vbr->u32MaxBitRate = bps_regular * 4 /3;
p_h264_vbr->u32MinQp = 24;
p_h264_vbr->u32MaxQp = 32;
break;
}
case SDK_ENC_H264_MODE_CBR:
case SDK_ENC_H264_MODE_ABR:
{
p_venc_rc_attr->enRcMode = VENC_RC_MODE_H264CBRv2;
p_h264_cbr->u32Gop = stream_attr->gop;
p_h264_cbr->u32StatTime = (stream_attr->gop + stream_attr->fps - 1) / stream_attr->fps;
p_h264_cbr->u32ViFrmRate = stream_attr->vin_fps;
p_h264_cbr->fr32TargetFrmRate = (typeof(p_h264_vbr->fr32TargetFrmRate))stream_attr->fps;
p_h264_cbr->u32BitRate = bps_regular;
p_h264_cbr->u32FluctuateLevel = 0;
break;
}
case SDK_ENC_H264_MODE_FIXQP:
{
p_venc_rc_attr->enRcMode = VENC_RC_MODE_H264FIXQP;
p_h264_fixqp->u32Gop = stream_attr->gop;
p_h264_fixqp->u32ViFrmRate = stream_attr->vin_fps;
p_h264_fixqp->fr32TargetFrmRate = (typeof(p_h264_vbr->fr32TargetFrmRate))stream_attr->fps;
p_h264_fixqp->u32IQp = 20;
p_h264_fixqp->u32PQp = 23;
break;
}
default:
{
SOC_TRACE("H264 encode mode %d not supported!", stream_attr->mode);
break;
}
}
SOC_CHECK(HI_MPI_VENC_CreateChn(venc_ch, &venc_chn_attr));
SOC_CHECK(HI_MPI_VENC_RegisterChn(venc_ch, venc_group));
memset(&mpp_chn_vpss, 0, sizeof(mpp_chn_vpss));
memset(&mpp_chn_venc, 0, sizeof(mpp_chn_venc));
// binding venc to vpss
mpp_chn_vpss.enModId = HI_ID_VPSS;
mpp_chn_vpss.s32DevId = vpss_group;
mpp_chn_vpss.s32ChnId = vpss_ch;
mpp_chn_venc.enModId = HI_ID_GROUP;
mpp_chn_venc.s32DevId = venc_group;
mpp_chn_venc.s32ChnId = venc_ch;
SOC_CHECK(HI_MPI_SYS_Bind(&mpp_chn_vpss, &mpp_chn_venc));
// set h264 reference mode
SOC_CHECK(HI_MPI_VENC_GetH264eRefMode(venc_ch, &venc_attr_h264_ref_mode));
switch(stream_attr->ref_mode) {
case SDK_ENC_H264_REF_MODE_1X:
venc_attr_h264_ref_mode = H264E_REF_MODE_1X;
break;
case SDK_ENC_H264_REF_MODE_2X:
venc_attr_h264_ref_mode = H264E_REF_MODE_2X;
break;
case SDK_ENC_H264_REF_MODE_4X:
venc_attr_h264_ref_mode = H264E_REF_MODE_4X;
break;
}
SOC_CHECK(HI_MPI_VENC_SetH264eRefMode(venc_ch, venc_attr_h264_ref_mode));
// create a new video encode engine
return SDK_SUCCESS;
}
}
return SDK_FAILURE;
}
