aaclc的解码器注册失败

zhwa

用的sdk是Hi3559V200_MobileCam_SDK_V1.0.1.5

只用hi3559v200的音频部分，音频数据流程有acap->aenc，编码数据存buf，buf->adec->ao;在acap、aenc、ao通道创建完和通道启动后，做了adec的初始化，里面包括了aaclc解码器的注册，可是在HI_MPI_ADEC_RegisterDecoder(&s32Handle, &stAac);出错了，错误代码为：0xA0188009 HI_ERR_ADEC_NOT_PERM 操作不允许。这是sdk带的源代码啊！

在PDT_MEDIA_Rebuild()函数中依次调用了：
1. /** init media */
    s32Ret = PDT_MEDIA_Init(&pstMediaCfg->stViVpssMode, &pstMediaCfg->stVBCfg, bLoadDsp);
2. /**初始化acap、aenc  */
s32Ret = HI_PDT_MEDIA_AudioInit(&(pstMediaCfg->stAudioCfg));
3. /** init audio out */
    s32Ret = HI_PDT_MEDIA_AudioOutStart(&(pstMediaCfg->stAudioOutCfg));
4. /**初始化解码   */
        AdecHdl = 0;
        HI_PDT_MEDIA_ADEC_CFG_S Adec_AttrCfg;
        Adec_AttrCfg.stADec_Attr.enAdecFormat = 0;
        Adec_AttrCfg.stADec_Attr.enMode = 0;
        HI_MAPI_ADEC_Init(AdecHdl, &(Adec_AttrCfg.stADec_Attr));

/***************************************/

HI_S32 HI_PDT_MEDIA_AudioInit(const HI_PDT_MEDIA_AUDIO_CFG_S* pstAudioCfg)
{
    HI_APPCOMM_CHECK_POINTER(pstAudioCfg, HI_PDT_MEDIA_EINVAL);
    PDT_MEDIA_CHECK_INIT(s_stMEDIACtx.bMediaInit);
    if (HI_TRUE == s_stMEDIACtx.bAudioInit)
    {
        MLOGD("already Init.\n");
        return HI_PDT_MEDIA_EINITIALIZED;
    }
    memcpy(&s_stMEDIACtx.pstMediaInfo->stMediaCfg.stAudioCfg, pstAudioCfg, sizeof(HI_PDT_MEDIA_AUDIO_CFG_S));

    const HI_PDT_MEDIA_ACAP_CFG_S* pstAcapCfg = NULL;
    const HI_PDT_MEDIA_AENC_CFG_S* pstAencCfg = NULL;
    HI_S32 s32Ret = HI_SUCCESS;
    HI_S32 s32AcapIdx, s32AcapChnlIdx, s32AencIdx;

    for (s32AcapIdx = 0; s32AcapIdx < HI_PDT_MEDIA_ACAP_MAX_CNT; ++s32AcapIdx)
    {
        pstAcapCfg = &pstAudioCfg->astAcapCfg[s32AcapIdx];
               
                printf("%s:%d  s32AcapIdx:%d pstAcapCfg：%d\n", __FILE__, __LINE__,s32AcapIdx, pstAcapCfg->bEnable);
        if (!pstAcapCfg->bEnable)
        {
            continue;
        }
                printf("%s:%d\n", __FILE__, __LINE__);

        MLOGD("AcapHdl[%d] SampleRate[%d] BitWidth[%dbit] SoundMode[%d:0-left,1-right,3-stereo]\n",
            pstAcapCfg->AcapHdl, pstAcapCfg->stAcapAttr.enSampleRate,
            (pstAcapCfg->stAcapAttr.enBitwidth + 1) << 3, pstAcapCfg->stAcapAttr.enSoundMode);
        MLOGD("  WorkMode[%d:0-master,1-slave] PtNumPerFrm[%u]\n",
            pstAcapCfg->stAcapAttr.enWorkmode, pstAcapCfg->stAcapAttr.u32PtNumPerFrm);
        MLOGD("  MixerMicMode[%d:0-in0,1-in1,2-inD] ResampleRate[%d]\n",
            pstAcapCfg->stAcapAttr.enMixerMicMode, pstAcapCfg->stAcapAttr.enResampleRate);
        HI_PERFORMANCE_TIME_STAMP;
                printf("%s:%d  AcapHdl:%d\n", __FILE__, __LINE__, pstAcapCfg->AcapHdl);
                printf("sampleRate:%d  bitwidth:%d  soundmod:%d tranckmode:%d workmode:%d  ptnumperframe:%d\
                           mixermicmode:%d resampletrate:%d i2stype:%d\n", pstAcapCfg->stAcapAttr.enSampleRate, pstAcapCfg->stAcapAttr.enBitwidth,\
                           pstAcapCfg->stAcapAttr.enSoundMode, pstAcapCfg->stAcapAttr.enTrackMode, pstAcapCfg->stAcapAttr.enWorkmode,pstAcapCfg->stAcapAttr.u32PtNumPerFrm, \
                           pstAcapCfg->stAcapAttr.enMixerMicMode, pstAcapCfg->stAcapAttr.enResampleRate, pstAcapCfg->stAcapAttr.enI2sType);
        s32Ret = HI_MAPI_ACAP_Init(pstAcapCfg->AcapHdl, &pstAcapCfg->stAcapAttr);
        HI_PERFORMANCE_TIME_STAMP;
                                printf("%s:%d\n", __FILE__, __LINE__);
        HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);

        for (s32AcapChnlIdx = 0; s32AcapChnlIdx < HI_PDT_MEDIA_ACAP_CHNL_MAX_CNT; ++s32AcapChnlIdx)
        {
            if(HI_TRUE == pstAcapCfg->AcapChnlCfg[s32AcapChnlIdx].bEnable)
            {
                HI_PERFORMANCE_TIME_STAMP;
                s32Ret = HI_MAPI_ACAP_Start(pstAcapCfg->AcapHdl,
                    pstAcapCfg->AcapChnlCfg[s32AcapChnlIdx].AcapChnlHdl);
#if (defined(AMP_LINUX_HUAWEILITE) && !defined(__HuaweiLite__)) || defined(AMP_HUAWEILITE) || defined(AMP_LINUX)
                if(HI_TRUE == pstAcapCfg->AcapChnlCfg[s32AcapChnlIdx].bEnableVqe)
                {
                    s32Ret |= HI_MAPI_ACAP_EnableRecordVqe(pstAcapCfg->AcapHdl,
                        pstAcapCfg->AcapChnlCfg[s32AcapChnlIdx].AcapChnlHdl);
                }
#endif
                HI_PERFORMANCE_TIME_STAMP;
                HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);
            }
        }
                printf("%s:%d\n", __FILE__, __LINE__);

        MLOGD("  AudioGain[%d]\n", pstAcapCfg->s32AudioGain);
        HI_PERFORMANCE_TIME_STAMP;
        s32Ret = HI_MAPI_ACAP_SetVolume(pstAcapCfg->AcapHdl, pstAcapCfg->s32AudioGain);
        HI_PERFORMANCE_TIME_STAMP;
        HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);

        for (s32AencIdx = 0; s32AencIdx < HI_PDT_MEDIA_AENC_MAX_CNT; ++s32AencIdx)
        {
            pstAencCfg = &pstAudioCfg->astAencCfg[s32AencIdx];
            if ( (pstAcapCfg->AcapHdl != pstAencCfg->AcapHdl) || (!pstAencCfg->bEnable))
            {
                continue;
            }

#if (defined(AMP_LINUX_HUAWEILITE) && !defined(__HuaweiLite__)) || defined(AMP_HUAWEILITE) || defined(AMP_LINUX)
            MUTEX_LOCK(s_stMEDIACtx.CntMutex);
            s_stMEDIACtx.as32AencStartCnt[s32AencIdx] = 0;
            MUTEX_UNLOCK(s_stMEDIACtx.CntMutex);
#endif
                        printf("%s:%d\n", __FILE__, __LINE__);

            MLOGD("AencHdl[%d] AencFormat[%d:0-aaclc,1-opus]\n", pstAencCfg->AencHdl,pstAencCfg->enFormat);
            HI_PERFORMANCE_TIME_STAMP;
            s32Ret = HI_MAPI_AENC_RegisterAudioEncoder(pstAencCfg->enFormat);
            HI_PERFORMANCE_TIME_STAMP;
            HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);

            /**need to be check*/
            HI_MAPI_AENC_ATTR_S stAencAttr;
            stAencAttr.enAencFormat   = HI_MAPI_AUDIO_FORMAT_AACLC;
            stAencAttr.u32PtNumPerFrm = pstAencCfg->u32PtNumPerFrm;
            stAencAttr.pValue         =
                &s_stMEDIACtx.pstMediaInfo->stMediaCfg.stAudioCfg.astAencCfg[s32AencIdx].unAttr.stAACAttr;
            stAencAttr.u32Len         = sizeof(HI_MAPI_AENC_ATTR_AAC_S);
                        printf("%s:%d\n", __FILE__, __LINE__);

            HI_PERFORMANCE_TIME_STAMP;
            s32Ret = HI_MAPI_AENC_Init(pstAencCfg->AencHdl, &stAencAttr);
            HI_PERFORMANCE_TIME_STAMP;
            HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);
        }
    }
        printf("%s:%d\n", __FILE__, __LINE__);

    s_stMEDIACtx.bAudioInit = HI_TRUE;
    MLOGD("Success\n");
    return HI_SUCCESS;
}

HI_S32 HI_PDT_MEDIA_VideoOutStart(HI_VOID)
{
    PDT_MEDIA_CHECK_INIT(s_stMEDIACtx.bMediaInit);
    PDT_MEDIA_CHECK_INIT(s_stMEDIACtx.bVideoOutInit);

    const HI_PDT_MEDIA_DISP_CFG_S* pstDispCfg = NULL;
    HI_S32 s32Ret = HI_SUCCESS;
    HI_S32 i, j;

#if (defined(AMP_LINUX_HUAWEILITE) && !defined(__HuaweiLite__))
    static HI_BOOL bFirst = HI_TRUE;
    if (bFirst)
    {
        bFirst = HI_FALSE;
        MLOGD("disp start[%d]\n", s_stMEDIACtx.pstMediaInfo->bDispStart);
        if (s_stMEDIACtx.pstMediaInfo->bDispStart)
        {
            MLOGI("fastboot ignore first\n");

            /** refresh as32VpssVportStartCnt*/
            for (i = 0; i < HI_PDT_MEDIA_DISP_MAX_CNT; ++i)
            {
                pstDispCfg = &s_stMEDIACtx.pstMediaInfo->stMediaCfg.stVideoOutCfg.astDispCfg;
                if (!pstDispCfg->bEnable)
                {
                    continue;
                }

                for (j = 0; j < HI_PDT_MEDIA_DISP_WND_MAX_CNT; ++j)
                {
                    if (!pstDispCfg->astWndCfg[j].bEnable)
                    {
                        continue;
                    }

                    if (HI_PDT_MEDIA_VIDEOMOD_VPSS == pstDispCfg->astWndCfg[j].enBindedMod)
                    {
                        MUTEX_LOCK(s_stMEDIACtx.CntMutex);
                        s_stMEDIACtx.as32VpssVportStartCnt[pstDispCfg->astWndCfg[j].ModHdl][pstDispCfg->astWndCfg[j].ChnHdl]++;
                        MUTEX_UNLOCK(s_stMEDIACtx.CntMutex);
                    }
                }
            }
            return HI_SUCCESS;
        }
    }
#endif

    for (i = 0; i < HI_PDT_MEDIA_DISP_MAX_CNT; ++i)
    {
        pstDispCfg = &s_stMEDIACtx.pstMediaInfo->stMediaCfg.stVideoOutCfg.astDispCfg;
        if (!pstDispCfg->bEnable)
        {
            continue;
        }

        if (pstDispCfg->stCscAttr.bEnable)
        {
            MLOGI(YELLOW"set csc in video out start\n"NONE);
            HI_PERFORMANCE_TIME_STAMP;
            s32Ret = HI_MAPI_DISP_SetAttrEx(pstDispCfg->VdispHdl, HI_MAPI_DISP_CMD_VIDEO_CSC,
                (HI_VOID*)&pstDispCfg->stCscAttr.stAttrEx, sizeof(HI_MAPI_DISP_CSCATTREX_S));
            HI_PERFORMANCE_TIME_STAMP;
            HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);
        }

        for (j = 0; j < HI_PDT_MEDIA_DISP_WND_MAX_CNT; ++j)
        {
            if (!pstDispCfg->astWndCfg[j].bEnable)
            {
                continue;
            }
            HI_MAPI_DISP_WINDOW_ROTATE_S stDispRotate;
            stDispRotate.enDispRorate = pstDispCfg->astWndCfg[j].enRotate;
            HI_PERFORMANCE_TIME_STAMP;
            s32Ret = HI_MAPI_DISP_SetWindowAttrEx(pstDispCfg->VdispHdl,
                    pstDispCfg->astWndCfg[j].WndHdl, HI_MAPI_DISP_WINDOW_CMD_ROTATE,
                    (HI_VOID*)&stDispRotate, sizeof(HI_MAPI_DISP_WINDOW_ROTATE_S));
            HI_PERFORMANCE_TIME_STAMP;
            HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);
        }

        HI_PERFORMANCE_TIME_STAMP;
        s32Ret = HI_MAPI_DISP_Start(pstDispCfg->VdispHdl,
            (HI_MAPI_DISP_VIDEOLAYER_ATTR_S *)&pstDispCfg->stVideoLayerAttr);
        HI_PERFORMANCE_TIME_STAMP;
        HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);

        s32Ret = PDT_MEDIA_VoWndStart(pstDispCfg);
        HI_APPCOMM_CHECK_RETURN(s32Ret, HI_FAILURE);



#if (defined(AMP_LINUX_HUAWEILITE) && !defined(__HuaweiLite__)) || defined(AMP_HUAWEILITE) || defined(AMP_LINUX)
        if (VO_INTF_HDMI == pstDispCfg->stDispAttr.stPubAttr.enIntfType)
        {
            s32Ret = PDT_MEDIA_HDMI_Start();
            s_stMEDIACtx.bHDMIStart = ((HI_SUCCESS == s32Ret) ? HI_TRUE : HI_FALSE);
        }
#endif
    }

    s_stMEDIACtx.pstMediaInfo->bDispStart = HI_TRUE;
    MLOGI("Success\n");
    return HI_SUCCESS;
}

HI_S32 HI_MAPI_ADEC_Init(HI_HANDLE AdecHdl, const HI_MAPI_ADEC_ATTR_S* pstAdecAttr)
{
    HI_S32 s32Ret;
    ADEC_CHN AdChn = AdecHdl;
    ADEC_CHN_ATTR_S stAdecChnAttr;
    ADEC_ATTR_AAC_S stAdecAAC;
    ADEC_ATTR_G711_S stAdecG711;

    CHECK_MAPI_ADEC_NULL_PTR_RET(pstAdecAttr);
    CHECK_MAPI_ADEC_HANDLE_RANGE_RET(AdecHdl);
    MUTEX_LOCK(g_adecFuncLock[AdecHdl]);
        printf("%s:%d\n", __FILE__, __LINE__);

    // Adec module init
    s32Ret = MAPI_ADEC_Init();
    if(s32Ret != HI_SUCCESS) {
        MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "MAPI_ADEC_Init error.\n");
        MUTEX_UNLOCK(g_adecFuncLock[AdecHdl]);
        return s32Ret;
    }
        printf("%s:%d\n", __FILE__, __LINE__);


    if(g_stAdecContext.astAdecChn[AdecHdl].bChnInited) {
        MAPI_WARN_TRACE(HI_MAPI_MOD_ADEC, "adec is Inited, no need init adec repeatedly!.\n");
        MUTEX_UNLOCK(g_adecFuncLock[AdecHdl]);
        return HI_SUCCESS;
    }
        printf("%s:%d\n", __FILE__, __LINE__);

   s32Ret = MAPI_ADEC_RegisterAudioDecoder(pstAdecAttr->enAdecFormat);
    if(s32Ret != HI_SUCCESS) {
        MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "MAPI_Register_AudioDecoder error.\n");
        MUTEX_UNLOCK(g_adecFuncLock[AdecHdl]);
        return s32Ret;
    }
        printf("%s:%d\n", __FILE__, __LINE__);

    stAdecChnAttr.u32BufSize = MAPI_ADEC_DEFAULT_BUF_SIZE;
    stAdecChnAttr.enMode = pstAdecAttr->enMode;

    switch(pstAdecAttr->enAdecFormat) {
        case HI_MAPI_AUDIO_FORMAT_AACLC: {
                stAdecChnAttr.enType = PT_AAC;
                stAdecChnAttr.pValue = &stAdecAAC;
                stAdecAAC.enTransType = AAC_TRANS_TYPE_ADTS;
            }
            break;

        case HI_MAPI_AUDIO_FORMAT_G711A: {
                stAdecChnAttr.enType = PT_G711A;
                stAdecChnAttr.pValue = &stAdecG711;
            }
            break;

        case HI_MAPI_AUDIO_FORMAT_G711U: {
                stAdecChnAttr.enType = PT_G711U;
                stAdecChnAttr.pValue = &stAdecG711;
            }
            break;

        default:
            MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "Do not support adec type %d \n", pstAdecAttr->enAdecFormat);
            s32Ret = MAPI_ADEC_UnRegisterAudioDecoder(pstAdecAttr->enAdecFormat);
            if(s32Ret != HI_SUCCESS) {
                MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "MAPI_UnRegister_AudioDecoder error.\n");
            }
            MUTEX_UNLOCK(g_adecFuncLock[AdecHdl]);
            return HI_MAPI_ADEC_EILLPARAM;
    }
        printf("%s:%d\n", __FILE__, __LINE__);

    s32Ret = HI_MPI_ADEC_CreateChn(AdChn, &stAdecChnAttr);
    if(s32Ret != HI_SUCCESS) {
        MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "HI_MPI_ADEC_CreateChn error.\n");
        s32Ret = MAPI_ADEC_UnRegisterAudioDecoder(pstAdecAttr->enAdecFormat);
        if(s32Ret != HI_SUCCESS) {
            MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "MAPI_UnRegister_AudioDecoder error.\n");
        }
        MUTEX_UNLOCK(g_adecFuncLock[AdecHdl]);
        return s32Ret;
    }
        printf("%s:%d\n", __FILE__, __LINE__);

    g_stAdecContext.astAdecChn[AdecHdl].bChnInited = HI_TRUE;
    g_stAdecContext.astAdecChn[AdecHdl].enAdecFormat = pstAdecAttr->enAdecFormat;
    MUTEX_UNLOCK(g_adecFuncLock[AdecHdl]);

    return s32Ret;
}


static HI_S32 MAPI_ADEC_RegisterAudioDecoder(HI_MAPI_AUDIO_FORMAT_E enAudioFormat)
{
    HI_S32 s32Ret = HI_SUCCESS;

    switch (enAudioFormat) {
        case HI_MAPI_AUDIO_FORMAT_AACLC:
            s32Ret = MAPI_ADEC_RegisterAac();
            if (s32Ret != HI_SUCCESS) {
                MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "MAPI_ADEC_RegisterAac failed, s32Ret:%x\n",s32Ret);
                return s32Ret;
            }

            break;
        /* not need Register Decoder */
        case HI_MAPI_AUDIO_FORMAT_G711A:
        case HI_MAPI_AUDIO_FORMAT_G711U:
            break;

        default:
            MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "not support the AudioFormat in register AudioDecoder!\n");
            return HI_MAPI_ADEC_EILLPARAM;
    }

    return HI_SUCCESS;
}

HI_S32 MAPI_ADEC_RegisterAac(HI_VOID)
{
    HI_S32 s32Ret;
    HI_S32 s32Handle = HI_INVALID_HANDLE;
    ADEC_DECODER_S stAac;

    if (g_s32AacDecHandle != HI_INVALID_HANDLE) {
        MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "aacDec have inited, return successful \n");
        return HI_SUCCESS;
    }

    stAac.enType = PT_AAC;
    s32Ret = snprintf_s(stAac.aszName, sizeof(stAac.aszName), sizeof(stAac.aszName), "Aac");
    if (s32Ret == HI_FAILURE) {
        MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "snprintf_s error:%#x \n", s32Ret);
        return HI_MAPI_SYS_ESAFEFUNC_OPERATE_FAIL;
    }

    stAac.pfnOpenDecoder = OpenAACDecoder;
    stAac.pfnDecodeFrm = DecodeAACFrm;
    stAac.pfnGetFrmInfo = GetAACFrmInfo;
    stAac.pfnCloseDecoder = CloseAACDecoder;
    stAac.pfnResetDecoder = ResetAACDecoder;
    s32Ret = HI_MPI_ADEC_RegisterDecoder(&s32Handle, &stAac);
    if (s32Ret != HI_SUCCESS) {
        MAPI_ERR_TRACE(HI_MAPI_MOD_ADEC, "HI_MPI_ADEC_RegisterDecoder return ERR, %x", s32Ret);
        return s32Ret;
    }

    g_s32AacDecHandle = s32Handle;

    return HI_SUCCESS;
}
在红色字体HI_MPI_ADEC_RegisterDecoder部分报错了，也就是在注册AAC解码器时出错了，这也是文档里的注册例子啊，HI_MAPI_ADEC_Init（）部分是SDK的原始代码。

其他地方也没有调用HI_MPI_ADEC_RegisterDecoder注册aac解码器，流程不对吗？大家指点下吧

zhwa

应该是其他地方注册了，解码器不允许重复注册，程序里只保留这个HI_MAPI_ADEC_Init()就ok