839 lines
24 KiB
C
839 lines
24 KiB
C
/******************************************************************************
|
|
Copyright (C), 2001-2016, Allwinner Tech. Co., Ltd.
|
|
******************************************************************************
|
|
File Name : mpi_ai.c
|
|
Version : Initial Draft
|
|
Author : Allwinner BU3-PD2 Team
|
|
Created : 2016/04/28
|
|
Last Modified :
|
|
Description : mpi functions implement
|
|
Function List :
|
|
History :
|
|
******************************************************************************/
|
|
|
|
//#define LOG_NDEBUG 0
|
|
#define LOG_TAG "mpi_ai"
|
|
#include <utils/plat_log.h>
|
|
|
|
//ref platform headers
|
|
#include <plat_type.h>
|
|
#include <plat_errno.h>
|
|
#include <plat_defines.h>
|
|
#include <plat_math.h>
|
|
#include <cdx_list.h>
|
|
|
|
//media api headers to app
|
|
#include <mm_common.h>
|
|
#include <media_common.h>
|
|
#include <AIOCompStream.h>
|
|
#include <audio_hw.h>
|
|
|
|
|
|
static AI_CHANNEL_S *AIChannel_Construct(void)
|
|
{
|
|
AI_CHANNEL_S *pChn = (AI_CHANNEL_S*)malloc(sizeof(AI_CHANNEL_S));
|
|
if (pChn == NULL) {
|
|
aloge("alloc AI_CHANNEL_S error[%s]!", strerror(errno));
|
|
return NULL;
|
|
}
|
|
memset(pChn, 0, sizeof(AI_CHANNEL_S));
|
|
cdx_sem_init(&pChn->mSemCompCmd, 0);
|
|
return pChn;
|
|
}
|
|
|
|
static void AIChannel_Destruct(AI_CHANNEL_S *pChn)
|
|
{
|
|
if (pChn != NULL) {
|
|
if (pChn->mpComp != NULL) {
|
|
aloge("fatal error! AI component need free before!");
|
|
COMP_FreeHandle(pChn->mpComp);
|
|
pChn->mpComp = NULL;
|
|
}
|
|
}
|
|
cdx_sem_deinit(&pChn->mSemCompCmd);
|
|
free(pChn);
|
|
}
|
|
|
|
static ERRORTYPE AIChannel_EventHandler(
|
|
PARAM_IN COMP_HANDLETYPE hComponent,
|
|
PARAM_IN void *pAppData,
|
|
PARAM_IN COMP_EVENTTYPE eEvent,
|
|
PARAM_IN unsigned int nData1,
|
|
PARAM_IN unsigned int nData2,
|
|
PARAM_IN void *pEventData)
|
|
{
|
|
//ERRORTYPE ret;
|
|
//MPP_CHN_S aiChnInfo;
|
|
//MM_COMPONENTTYPE *pComp = (MM_COMPONENTTYPE*)hComponent;
|
|
AI_CHANNEL_S *pChn = (AI_CHANNEL_S*)pAppData;
|
|
|
|
//ret = pComp->GetConfig(hComponent, COMP_IndexVendorMPPChannelInfo, &aiChnInfo);
|
|
//alogv("audio device event, MppChannel[%d][%d][%d]", aiChnInfo.mModId, aiChnInfo.mDevId, aiChnInfo.mChnId);
|
|
|
|
switch(eEvent)
|
|
{
|
|
case COMP_EventCmdComplete:
|
|
{
|
|
if(COMP_CommandStateSet == nData1)
|
|
{
|
|
alogv("audio device EventCmdComplete, current StateSet[%d]", nData2);
|
|
cdx_sem_up(&pChn->mSemCompCmd);
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
alogw("Low probability! what data[%#x, %#x]?", nData1, nData2);
|
|
break;
|
|
}
|
|
}
|
|
case COMP_EventError:
|
|
{
|
|
if(ERR_AI_INVALIDSTATE == nData1)
|
|
{
|
|
aloge("Impossible! Ai chn in invalid state!");
|
|
}
|
|
else if(ERR_AI_INCORRECT_STATE_TRANSITION == nData1)
|
|
{
|
|
aloge("Ai chn happen wrong state transition!");
|
|
}
|
|
else if(ERR_AI_SAMESTATE == nData1)
|
|
{
|
|
aloge("AI chn change state to the same!");
|
|
}
|
|
else
|
|
{
|
|
aloge("Ai chn happen ErrorEvent with data[%#x, %#x]", nData1, nData2);
|
|
}
|
|
break;
|
|
}
|
|
case COMP_EventBufferPrefilled:
|
|
{
|
|
if(pChn->mCallbackInfo.callback)
|
|
{
|
|
MPP_CHN_S ChannelInfo = {MOD_ID_AI, pChn->mDevId, pChn->mId};
|
|
AISendDataInfo *pUserData = (AISendDataInfo*)pEventData;
|
|
pChn->mCallbackInfo.callback(pChn->mCallbackInfo.cookie, &ChannelInfo, MPP_EVENT_CAPTURE_AUDIO_DATA, (void*)pUserData);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
aloge("fatal error! unknown event[0x%x]", eEvent);
|
|
break;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
static COMP_CALLBACKTYPE AIChannel_Callback = {
|
|
.EventHandler = AIChannel_EventHandler,
|
|
.EmptyBufferDone = NULL,
|
|
.FillBufferDone = NULL,
|
|
};
|
|
|
|
/**
|
|
set callback to aiChn.
|
|
aiChn will use callback to transmit info to app.
|
|
*/
|
|
ERRORTYPE AW_MPI_AI_RegisterCallback(AUDIO_DEV AudioDevId, AI_CHN AiChn, MPPCallbackInfo *pCallback)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
pChn->mCallbackInfo.callback = pCallback->callback;
|
|
pChn->mCallbackInfo.cookie = pCallback->cookie;
|
|
return SUCCESS;
|
|
}
|
|
|
|
/**
|
|
set callback to AudioDev.
|
|
must be called before AW_MPI_AI_Enable(), because the latter may use callback to get some informations.
|
|
*/
|
|
ERRORTYPE AW_MPI_AI_RegisterDevCallback(AUDIO_DEV AudioDevId, void *cookie, AudioDevCallbackFuncType pAudioDevCallback)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetCallback(AudioDevId, cookie, pAudioDevCallback);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetPubAttr(AUDIO_DEV AudioDevId, const AIO_ATTR_S *pstAttr)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetPubAttr(AudioDevId, pstAttr);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetPubAttr(AUDIO_DEV AudioDevId, AIO_ATTR_S *pstAttr)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_GetPubAttr(AudioDevId, pstAttr);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_ClrPubAttr(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_ClrPubAttr(AudioDevId);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_Enable(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_Enable(AudioDevId);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_Disable(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_Disable(AudioDevId);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetTrackMode(AUDIO_DEV AudioDevId, AUDIO_TRACK_MODE_E enTrackMode)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetTrackMode(AudioDevId, enTrackMode);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetTrackMode(AUDIO_DEV AudioDevId, AUDIO_TRACK_MODE_E *penTrackMode)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_GetTrackMode(AudioDevId, penTrackMode);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_CreateChn(AUDIO_DEV AudioDevId, AI_CHN AiChn, const AI_CHN_ATTR_S *pAttr)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret = SUCCESS;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId))
|
|
{
|
|
ret = audioHw_AI_Enable(AudioDevId);
|
|
if (ret != SUCCESS)
|
|
{
|
|
aloge("enable AiDev failed!");
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
}
|
|
audioHw_AI_Dev_lock(AudioDevId);
|
|
ret = audioHw_AI_searchChannel_l(AudioDevId, AiChn, &pChn);
|
|
if (SUCCESS != ret)
|
|
{
|
|
pChn = AIChannel_Construct();
|
|
if (pChn == NULL)
|
|
{
|
|
audioHw_AI_Dev_unlock(AudioDevId);
|
|
return ERR_AI_NOMEM;
|
|
}
|
|
pChn->mDevId = AudioDevId;
|
|
pChn->mId = AiChn;
|
|
ret = COMP_GetHandle((COMP_HANDLETYPE*)&pChn->mpComp, CDX_ComponentNameAIChannel, (void*)pChn, &AIChannel_Callback);
|
|
MPP_CHN_S ChannelInfo;
|
|
ChannelInfo.mModId = MOD_ID_AI;
|
|
ChannelInfo.mDevId = AudioDevId;
|
|
ChannelInfo.mChnId = AiChn;
|
|
ret = COMP_SetConfig(pChn->mpComp, COMP_IndexVendorMPPChannelInfo, (void*)&ChannelInfo);
|
|
ret = COMP_SetConfig(pChn->mpComp, COMP_IndexVendorAIChnAttr, (void*)pAttr);
|
|
ret = COMP_SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StateIdle, NULL);
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
audioHw_AI_AddChannel_l(AudioDevId, pChn);
|
|
}
|
|
else
|
|
{
|
|
ret = ERR_AI_EXIST;
|
|
}
|
|
audioHw_AI_Dev_unlock(AudioDevId);
|
|
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_DestroyChn(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret = SUCCESS;
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
if (SUCCESS == audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn))
|
|
{
|
|
COMP_STATETYPE eState = COMP_StateInvalid;
|
|
ERRORTYPE eRet;
|
|
eRet = COMP_GetState(pChn->mpComp, &eState);
|
|
if(eRet == SUCCESS)
|
|
{
|
|
if(COMP_StateIdle == eState)
|
|
{
|
|
eRet = COMP_SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StateLoaded, NULL);
|
|
if(eRet != SUCCESS)
|
|
{
|
|
aloge("fatal error! comp turn state fail[0x%x]!", eRet);
|
|
}
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
}
|
|
else if(COMP_StateLoaded == eState)
|
|
{
|
|
eRet = SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! AiChn[%d,%d] wrong state:0x%x", AudioDevId, AiChn, eState);
|
|
eRet = FAILURE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! get status fail[0x%x]!", eRet);
|
|
}
|
|
audioHw_AI_RemoveChannel(AudioDevId, pChn);
|
|
audioHw_AI_Disable(AudioDevId);
|
|
COMP_FreeHandle(pChn->mpComp);
|
|
pChn->mpComp = NULL;
|
|
AIChannel_Destruct(pChn);
|
|
} else {
|
|
ret = ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_EnableChn(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret = SUCCESS;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
if (SUCCESS == audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
ret = pChn->mpComp->SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StateExecuting, NULL);
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
} else {
|
|
ret = ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_DisableChn(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
pChn->mpComp->SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StateIdle, NULL);
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_ResetChn(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
COMP_STATETYPE nCompState = COMP_StateInvalid;
|
|
ERRORTYPE eRet, eRet2;
|
|
eRet = pChn->mpComp->GetState(pChn->mpComp, &nCompState);
|
|
if(eRet == SUCCESS && COMP_StateIdle == nCompState)
|
|
{
|
|
eRet2 = pChn->mpComp->SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StateLoaded, NULL);
|
|
if(eRet2 != SUCCESS)
|
|
{
|
|
aloge("fatal error! reset channel fail[0x%x]!", eRet2);
|
|
}
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
return eRet2;
|
|
}
|
|
else
|
|
{
|
|
aloge("wrong status[0x%x], can't reset ai channel!", nCompState);
|
|
return ERR_AI_NOT_PERM;
|
|
}
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_PauseChn(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
int ret;
|
|
int eRet;
|
|
COMP_STATETYPE nCompState;
|
|
eRet = pChn->mpComp->GetState(pChn->mpComp, &nCompState);
|
|
if(COMP_StateExecuting == nCompState)
|
|
{
|
|
eRet = pChn->mpComp->SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StatePause, NULL);
|
|
if(eRet != SUCCESS)
|
|
{
|
|
aloge("fatal error! Send command statePause fail!");
|
|
}
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
ret = SUCCESS;
|
|
}
|
|
else if(COMP_StatePause == nCompState)
|
|
{
|
|
alogd("AIChannel[%d] already statePause.", AiChn);
|
|
ret = SUCCESS;
|
|
}
|
|
else if(COMP_StateIdle == nCompState)
|
|
{
|
|
alogd("AIChannel[%d] stateIdle, can't turn to statePause!", AiChn);
|
|
ret = ERR_AI_INCORRECT_STATE_OPERATION;
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! check AIChannel[%d] State[0x%x]!", AiChn, nCompState);
|
|
ret = ERR_AI_INCORRECT_STATE_OPERATION;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_ResumeChn(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
int ret;
|
|
int eRet;
|
|
COMP_STATETYPE nCompState;
|
|
eRet = pChn->mpComp->GetState(pChn->mpComp, &nCompState);
|
|
if(COMP_StatePause == nCompState)
|
|
{
|
|
eRet = pChn->mpComp->SendCommand(pChn->mpComp, COMP_CommandStateSet, COMP_StateExecuting, NULL);
|
|
if(eRet != SUCCESS)
|
|
{
|
|
aloge("fatal error! Send command statePause fail!");
|
|
}
|
|
cdx_sem_down(&pChn->mSemCompCmd);
|
|
ret = SUCCESS;
|
|
}
|
|
else if(COMP_StateExecuting == nCompState)
|
|
{
|
|
alogd("AIChannel[%d] already stateExecuting.", AiChn);
|
|
ret = SUCCESS;
|
|
}
|
|
else if(COMP_StateIdle == nCompState)
|
|
{
|
|
alogd("AIChannel[%d] stateIdle, can't turn to stateExecuting!", AiChn);
|
|
ret = ERR_AI_INCORRECT_STATE_OPERATION;
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! check AIChannel[%d] State[0x%x]!", AiChn, nCompState);
|
|
ret = ERR_AI_INCORRECT_STATE_OPERATION;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetFrame(AUDIO_DEV AudioDevId, AI_CHN AiChn, AUDIO_FRAME_S *pstFrm, AEC_FRAME_S *pstAecFrm, int s32MilliSec)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
AudioFrame audioFrm;
|
|
audioFrm.pFrame = pstFrm;
|
|
audioFrm.pAecFrame = pstAecFrm;
|
|
audioFrm.nMilliSec = s32MilliSec;
|
|
return pChn->mpComp->GetConfig(pChn->mpComp, COMP_IndexVendorAIChnGetValidFrame, &audioFrm);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_ReleaseFrame(AUDIO_DEV AudioDevId, AI_CHN AiChn, AUDIO_FRAME_S *pstFrm, AEC_FRAME_S *pstAecFrm)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
AudioFrame audioFrm;
|
|
audioFrm.pFrame = pstFrm;
|
|
audioFrm.pAecFrame = pstAecFrm;
|
|
audioFrm.nMilliSec = 0;
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIChnReleaseFrame, &audioFrm);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetChnParam(AUDIO_DEV AudioDevId, AI_CHN AiChn, AI_CHN_PARAM_S *pstChnParam)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIChnParameter, pstChnParam);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetChnParam(AUDIO_DEV AudioDevId, AI_CHN AiChn, AI_CHN_PARAM_S *pstChnParam)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
return pChn->mpComp->GetConfig(pChn->mpComp, COMP_IndexVendorAIChnParameter, pstChnParam);
|
|
}
|
|
|
|
//ERRORTYPE AW_MPI_AI_SetVqeAttr(AUDIO_DEV AiDevId, AI_CHN AiChn, AUDIO_DEV AoDevId, AO_CHN AoChn, AI_VQE_CONFIG_S *pstVqeConfig)
|
|
ERRORTYPE AW_MPI_AI_SetVqeAttr(AUDIO_DEV AiDevId, AI_CHN AiChn, AI_VQE_CONFIG_S *pstVqeConfig)
|
|
{
|
|
CHECK_AI_DEV_ID(AiDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
//CHECK_AO_DEV_ID(AoDevId);
|
|
//CHECK_AO_CHN_ID(AoChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AiDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AiDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIOVqeAttr, pstVqeConfig);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetVqeAttr(AUDIO_DEV AiDevId, AI_CHN AiChn, AI_VQE_CONFIG_S *pstVqeConfig)
|
|
{
|
|
CHECK_AI_DEV_ID(AiDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AiDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AiDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->GetConfig(pChn->mpComp, COMP_IndexVendorAIOVqeAttr, pstVqeConfig);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_EnableVqe(AUDIO_DEV AiDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AiDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AiDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AiDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIOVqeEnable, NULL);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_DisableVqe(AUDIO_DEV AiDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AiDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AiDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AiDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIOVqeDisable, NULL);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_IgnoreData(AUDIO_DEV AudioDevId, AI_CHN AiChn, BOOL bIgnore)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
return COMP_SetConfig(pChn->mpComp, COMP_IndexVendorAIIgnoreData, &bIgnore);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_EnableReSmp(AUDIO_DEV AudioDevId, AI_CHN AiChn, AUDIO_SAMPLE_RATE_E enOutSampleRate)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIOReSmpEnable, &enOutSampleRate);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_DisableReSmp(AUDIO_DEV AudioDevId, AI_CHN AiChn)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAIOReSmpDisable, NULL);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SaveFile(AUDIO_DEV AudioDevId, AI_CHN AiChn, AUDIO_SAVE_FILE_INFO_S *pstSaveFileInfo)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->SetConfig(pChn->mpComp, COMP_IndexVendorAISetSaveFileInfo, pstSaveFileInfo);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_QueryFileStatus(AUDIO_DEV AudioDevId, AI_CHN AiChn, AUDIO_SAVE_FILE_INFO_S *pstSaveFileInfo)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
return pChn->mpComp->GetConfig(pChn->mpComp, COMP_IndexVendorAIQueryFileStatus, pstSaveFileInfo);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetVqeVolume(AUDIO_DEV AudioDevId, AI_CHN AiChn, int s32VolumeDb)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
// todo
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetVqeVolume(AUDIO_DEV AudioDevId, AI_CHN AiChn, int *ps32VolumeDb)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
|
|
// todo
|
|
|
|
return SUCCESS;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetDevDrc(AUDIO_DEV AudioDevId, int enable)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetAdcDrc(AudioDevId, enable);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetDevHpf(AUDIO_DEV AudioDevId, int enable)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetAdcHpf(AudioDevId, enable);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetDevVolume(AUDIO_DEV AudioDevId, int s32VolumeDb)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetVolume(AudioDevId, s32VolumeDb);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetDevVolume(AUDIO_DEV AudioDevId, int *ps32VolumeDb)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_GetVolume(AudioDevId, ps32VolumeDb);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetDevMute(AUDIO_DEV AudioDevId, int bEnableFlag)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetMute(AudioDevId, bEnableFlag);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetDevMute(AUDIO_DEV AudioDevId, int *pbEnableFlag)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_GetMute(AudioDevId, pbEnableFlag);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetChnMute(AUDIO_DEV AudioDevId, AI_CHN AiChn, BOOL bMute)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
return COMP_SetConfig(pChn->mpComp, COMP_IndexVendorAIChnMute, &bMute);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetChnMute(AUDIO_DEV AudioDevId, AI_CHN AiChn, BOOL* pbMute)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
CHECK_AI_CHN_ID(AiChn);
|
|
AI_CHANNEL_S *pChn = NULL;
|
|
ERRORTYPE ret;
|
|
|
|
if (!audioHw_AI_IsDevStarted(AudioDevId)) {
|
|
return ERR_AI_NOT_ENABLED;
|
|
}
|
|
|
|
if (SUCCESS != audioHw_AI_searchChannel(AudioDevId, AiChn, &pChn)) {
|
|
return ERR_AI_UNEXIST;
|
|
}
|
|
return COMP_GetConfig(pChn->mpComp, COMP_IndexVendorAIChnMute, pbMute);
|
|
}
|
|
|
|
/*
|
|
* dynamic suspend/resume ans
|
|
* pCap->mAttr.ai_ans_en must be true, i.e. must enable ans first!
|
|
*/
|
|
ERRORTYPE AW_MPI_AI_SuspendAns(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SuspendAns(AudioDevId);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_ResumeAns(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_ResumeAns(AudioDevId);
|
|
}
|
|
|
|
/*
|
|
* dynamic suspend/resume aec
|
|
* pCap->mAttr.ai_aec_en must be true, i.e. must enable aec first!
|
|
*/
|
|
ERRORTYPE AW_MPI_AI_SuspendAec(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SuspendAec(AudioDevId);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_ResumeAec(AUDIO_DEV AudioDevId)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_ResumeAec(AudioDevId);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_SetAgcDb(AUDIO_DEV AudioDevId, float fDbGain)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_SetAgcDb(AudioDevId, fDbGain);
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_AI_GetAgcDb(AUDIO_DEV AudioDevId, float *pfDbGain)
|
|
{
|
|
CHECK_AI_DEV_ID(AudioDevId);
|
|
return audioHw_AI_GetAgcDb(AudioDevId, pfDbGain);
|
|
}
|
|
|