[结帖]关于音频数据的发送调用HI_MPI_AO_SendFrame

本帖最后由 yangjking 于 2016-11-19 15:23 编辑

Hi All，
    在前期使用sample_aio demo测试已经可用后。我就开始对接与远程手机的对讲demo。
    现在是手机接收从板子过来的声音成功，但是手机发送声音数据后，板子接收到数据，然后我调用HI_MPI_AO_SendFrame函数就报如下错误log。
------------------------------------错误 log ---------------------------------------
/tmp # ./testdanavideo
------test 21-------------
th_talkback join in
MMB LEAK(pid=1415): 0x84043000, 65536 bytes, 'AO(0,0) CirBuf'
mmz_userdev_release: mmb<0x84043000> mapped to userspace 0xb2d08000 will be force unmaped!
Segmentation fault
/tmp #
-------------------------------------------------------------------------------------
可否帮忙看下是哪出问题？
-----------------------------------------------------------------------------------------------------------------------
解决： 基本无法直接使用Ao_SendFrame。需经过dec再使用Ao，对于原始数据可用PT_LPCM来解压
----------------------------------------------------------------------------------------------------------------------
相关代码如下：
[code]///////////////////////////////////////////////////////////////////////
UCHAR run_flag = 0;

/*
*  线程1，手机发送声音数据给板子接收。
*  正确接收后，调用函数发送。
*  结果接收数据正常，但是audio_data_write里报错
*/
void* th_talkback(void *arg) {
    MYDATA *mydata = (MYDATA *)arg;
    int err = 0;
    uint32_t timeout_usec = 1000*1000; // 1000ms
        printf("%s join in\n", __FUNCTION__);
    while (mydata->run_talkback)
    {
        dana_audio_packet_t *pmsg = lib_readaudio(mydata->conn, timeout_usec);
        if (pmsg) {
                /*
                 *  run_flag 标志用于判断底层是否准备就绪
                 */
                        if (run_flag){
                                err = audio_data_write(pmsg->data , pmsg->len);
                                if(err < 0){
                                        printf("audio data write error!\n");
                                        mydata->run_talkback = 0;
                                }
                        }
            lib_audio_packet_destroy(pmsg);
        } else {
            usleep(10*1000); // 10ms
        }
    }

    printf("th_talkback exit\n");
    mydata->exit_talback = true;
    return NULL;
}

/*
* 线程二，mic通过板子发送音频给手机，这个可以正常运行。
*/
void* th_audio_media(void *arg)
{
    MYDATA *mydata = (MYDATA *)arg;

    uint32_t timeout_usec = 1000*1000; // 1000ms


    BYTE *pBuff = NULL;
    DWORD timestamp, media_type, size, isKeyFrame;

    DWORD timestamp_base = 0;
        int err = 0;

        printf("------test 21-------------\n");

        /*
        *   mpp 接口相关初始化。
        */
        err = audio_init();
        if (err < 0){
                printf("init audio false!\n");
                goto fin;
        }
        run_flag = 1;
       
    pBuff = (BYTE*) calloc(1, 300*1024);
    if (NULL == pBuff) {
        dbg("th_audio_media cant't calloc pBuff\n");
        goto fin;
    }
        size = 300*1024;
   
    while (mydata->run_audio_media)
        {
        err = audio_data_read(×tamp, &isKeyFrame, pBuff, size);
                if (err > 0){
                        dbg("%s:get the timestamp %d err %d\n", __FUNCTION__, timestamp, err);
                        timestamp = 0;
                        if (lib_conn_send(mydata->conn, audio_stream, PCM, mydata->chan_no, isKeyFrame,
                                timestamp + timestamp_base, (const char*)pBuff, err, timeout_usec)) {
                                dbg("th_audio_media send test file [%u] succeeded\n", size);
                        } else {
                                dbg("th_audio_media send test file [%u] failed\n", size);
                                usleep(200*1000);
                                continue;
                        }
               
        } else if (err < 0){
            dbg("th_audio_media read file error: %u\n", err);
        }

    }
    printf("%s exit while \n", __FUNCTION__);
fin:
    if (pBuff) {
        free(pBuff);
    }
        run_flag = 0;
        audio_delete();
    dbg("th_audio_media exit\n");
    mydata->exit_audio_media = true;
    return NULL;
}
#define SAMPLE_DBG(s32Ret)\
        do{\
                printf("s32Ret=%#x,fuc:%s,line:%d\n", s32Ret, __FUNCTION__, __LINE__);\
        }while(0)

static HI_S32 s32AiChnCnt                  = 0;   
static HI_S32 s32AoChnCnt                  = 0;          
static AUDIO_DEV   AiDev                   = SAMPLE_AUDIO_AI_DEV;          
static AI_CHN            AiChn                  = 0;       
static AUDIO_DEV        AoDev                  = SAMPLE_AUDIO_AO_DEV;       
static AO_CHN                AoChn                  = 0;
static AUDIO_SAMPLE_RATE_E enInSampleRate  = AUDIO_SAMPLE_RATE_BUTT;
static AUDIO_SAMPLE_RATE_E enOutSampleRate = AUDIO_SAMPLE_RATE_BUTT;
static HI_BOOL gs_bAioReSample             = HI_FALSE;
static HI_S32 AiFd                         = 0;


/******************************************************************************
* function : to process abnormal case
******************************************************************************/
static void SAMPLE_AUDIO_HandleSig(HI_S32 signo)
{   
        if (SIGINT == signo || SIGTERM == signo)   
        {        
                SAMPLE_COMM_AUDIO_DestoryAllTrd();        
                SAMPLE_COMM_SYS_Exit();        
                printf("\033[0;31mprogram exit abnormally!\033[0;39m\n");   
        }   
        exit(0);
}

int audio_init(void)
{
        HI_S32 s32Ret = HI_SUCCESS;
        VB_CONF_S stVbConf;
        AIO_ATTR_S stAiAttr, stAoAttr;
        AI_CHN_PARAM_S stAiChnPara;

    signal(SIGINT, SAMPLE_AUDIO_HandleSig);   
        signal(SIGTERM, SAMPLE_AUDIO_HandleSig);

    memset(&stVbConf, 0, sizeof(VB_CONF_S));   
        s32Ret = SAMPLE_COMM_SYS_Init(&stVbConf);   
        if (HI_SUCCESS != s32Ret)   
        {
                printf("%s: system init failed with %d!\n", __FUNCTION__, s32Ret);        
                return HI_FAILURE;   
        }
        /* set the ai attr */       
        stAiAttr.enSamplerate = AUDIO_SAMPLE_RATE_16000;       
        stAiAttr.enBitwidth = AUDIO_BIT_WIDTH_16;       
        stAiAttr.enWorkmode = AIO_MODE_I2S_SLAVE;       
        stAiAttr.enSoundmode = AUDIO_SOUND_MODE_STEREO;       
        stAiAttr.u32EXFlag = 0;       
        stAiAttr.u32FrmNum = 30;       
        stAiAttr.u32PtNumPerFrm = SAMPLE_AUDIO_PTNUMPERFRM;       
        stAiAttr.u32ChnCnt = 2;       
        stAiAttr.u32ClkSel = 0;       
        /* set the ao attr */       
        stAoAttr = stAiAttr;       
        stAoAttr.enWorkmode = AIO_MODE_I2S_MASTER;

        enInSampleRate        = AUDIO_SAMPLE_RATE_BUTT;                 
        enOutSampleRate = AUDIO_SAMPLE_RATE_BUTT;

        /* enable AI channle */   
        s32AiChnCnt = stAiAttr.u32ChnCnt;       
        s32Ret = SAMPLE_COMM_AUDIO_StartAi(AiDev, s32AiChnCnt, &stAiAttr, enOutSampleRate, gs_bAioReSample, NULL, 0);         
        if (s32Ret != HI_SUCCESS)          
        {           
                SAMPLE_DBG(s32Ret);                  
                return HI_FAILURE;       
        }

        /* enable AO channle */   
        s32AoChnCnt = stAoAttr.u32ChnCnt;       
        s32Ret = SAMPLE_COMM_AUDIO_StartAo(AoDev, s32AoChnCnt, &stAoAttr, enInSampleRate, gs_bAioReSample, NULL, 0);       
        if (s32Ret != HI_SUCCESS)         
        {                  
                SAMPLE_DBG(s32Ret);                 
                return HI_FAILURE;   
        }

        s32Ret = HI_MPI_AI_GetChnParam(AiDev, AiChn, &stAiChnPara);
        if (HI_SUCCESS != s32Ret)
        {
                printf("%s: Get ai chn param failed\n", __FUNCTION__);
                return -1;
        }
        stAiChnPara.u32UsrFrmDepth = 30;
    s32Ret = HI_MPI_AI_SetChnParam(AiDev, AiChn, &stAiChnPara);
    if (HI_SUCCESS != s32Ret)
    {
        printf("%s: set ai chn param failed\n", __FUNCTION__);
        return -1;
    }
        AiFd = HI_MPI_AI_GetFd(AiDev, AiChn);
       
        return HI_SUCCESS;
}

int audio_delete(void)
{
        HI_S32 s32Ret = HI_SUCCESS;
    s32Ret = SAMPLE_COMM_AUDIO_StopAi(AiDev, s32AiChnCnt, gs_bAioReSample, HI_FALSE);   
        if (s32Ret != HI_SUCCESS)   
        {        
                SAMPLE_DBG(s32Ret);        
                return HI_FAILURE;   
        }   
        s32Ret = SAMPLE_COMM_AUDIO_StopAo(AoDev, s32AoChnCnt, gs_bAioReSample, HI_FALSE);   
        if (s32Ret != HI_SUCCESS)   
        {        
                SAMPLE_DBG(s32Ret);        
                return HI_FAILURE;   
        }

        SAMPLE_COMM_SYS_Exit();
        printf("audio task delete\n");

        return HI_SUCCESS;
}

/*   A U D I O _ D A T A _ R E A D   */
/*-------------------------------------------------------------------------
    Owner: George Yang
        return success >0; no data =0;
   
-------------------------------------------------------------------------*/
int audio_data_read(DWORD *timeStamp, DWORD *flag, BYTE *buf, DWORD size)
{
        HI_S32 s32Ret;
       
        fd_set read_fds;
        struct timeval TimeoutVal;
       
       
        AUDIO_FRAME_S stFrame;
        AEC_FRAME_S   stAecFrm;
       
        TimeoutVal.tv_sec = 1;
        TimeoutVal.tv_usec = 0;

    FD_ZERO(&read_fds);
    FD_SET(AiFd, &read_fds);

        s32Ret = select(AiFd + 1, &read_fds, NULL, NULL, &TimeoutVal);
        if (s32Ret < 0)
        {
                printf("%s: select error \n", __FUNCTION__);
                return -1;
        }
        else if (0 == s32Ret)
        {
                printf("%s: get ai frame select time out\n", __FUNCTION__);
                return -1;
        }

        if (FD_ISSET(AiFd, &read_fds))
        {
                /* get frame from ai chn */
                memset(&stAecFrm, 0, sizeof(AEC_FRAME_S));
                s32Ret = HI_MPI_AI_GetFrame(AiDev, AiChn, &stFrame, &stAecFrm, HI_FALSE);
                if (HI_SUCCESS != s32Ret )
                {
                        printf("%s: HI_MPI_AI_GetFrame(%d, %d), failed with %#x!\n", \
                                   __FUNCTION__, AiDev, AiChn, s32Ret);
                        return -1;
                }

                if (stFrame.u32Len <= size){
                        size = stFrame.u32Len;
                } else {
                        printf("%s: the read size is not long enough!\n", size);
                }
                memcpy(buf, stFrame.pVirAddr[0], size);
               
                /* finally you must release the stream */
                s32Ret = HI_MPI_AI_ReleaseFrame(AiDev, AiChn, &stFrame, &stAecFrm);
                if (HI_SUCCESS != s32Ret )
                {
                        printf("%s: HI_MPI_AI_ReleaseFrame(%d, %d), failed with %#x!\n", \
                                   __FUNCTION__, AiDev, AiChn, s32Ret);
                        return -1;
                }

                *timeStamp = (stFrame.u64TimeStamp / 1000);
                *flag = 0;
               
                return size;
        }

        return 0;
}

int audio_data_write(char *data , DWORD len)
{
        HI_S32 s32Ret;
        AUDIO_FRAME_S stAoFrame;
        char *pAoBuf = malloc(len);

        memset(&stAoFrame, 0, sizeof(AUDIO_FRAME_S));
        memcpy(pAoBuf, data, len);
        stAoFrame.pVirAddr[0]   = (void *)pAoBuf;
        stAoFrame.u32Len        = len;
        stAoFrame.enBitwidth    = AUDIO_BIT_WIDTH_16;
        stAoFrame.enSoundmode   = AUDIO_SOUND_MODE_STEREO;
        stAoFrame.u64TimeStamp  = 0;
        stAoFrame.u32Seq        = 0;
       
        s32Ret = HI_MPI_AO_SendFrame(AoDev, AoChn, &stAoFrame, 1000);
        if (HI_SUCCESS != s32Ret )
        {
                printf("%s: HI_MPI_AO_SendFrame(%d, %d), failed with %#x!\n", \
                           __FUNCTION__, AoDev, AoChn, s32Ret);
                return -1;
        }

        free(stAoFrame.pVirAddr[0]);

        return 0;
}
[/code]