730 lines
24 KiB
C
Executable File
730 lines
24 KiB
C
Executable File
/*
|
|
******************************************************************************
|
|
*
|
|
* MPI_ISE.h
|
|
*
|
|
* Hawkview ISP - mpi_ise.h module
|
|
*
|
|
* Copyright (c) 2016 by Allwinnertech Co., Ltd. http://www.allwinnertech.com
|
|
*
|
|
* Version Author Date Description
|
|
*
|
|
* 1.0 yuanxianfeng 2016/07/01 ISE
|
|
*
|
|
*****************************************************************************
|
|
*/
|
|
|
|
#define LOG_TAG "mpi_ise"
|
|
#include <utils/plat_log.h>
|
|
|
|
// ref platform headers
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include "cdx_list.h"
|
|
#include "plat_defines.h"
|
|
#include "plat_errno.h"
|
|
#include "plat_math.h"
|
|
#include "plat_type.h"
|
|
|
|
// #include "mm_comm_vi.h"
|
|
#include "mm_comm_ise.h"
|
|
#include "mm_comm_video.h"
|
|
#include "mm_common.h"
|
|
#include "mpi_ise.h"
|
|
|
|
#include "media_common.h"
|
|
#include "mm_component.h"
|
|
#include "tsemaphore.h"
|
|
#include <VideoISECompStream.h>
|
|
// #include "vencoder.h"
|
|
|
|
typedef struct {
|
|
ISE_GRP mIseGrp; // ISE group id, [0, ISE_MAX_GRP_NUM)
|
|
MM_COMPONENTTYPE *mComp; // ISE component instance
|
|
cdx_sem_t mSemCompCmd;
|
|
cdx_sem_t mSemAddChn;
|
|
cdx_sem_t mSemRemoveChn;
|
|
|
|
MPPCallbackInfo mCallbackInfo;
|
|
struct list_head mList;
|
|
} ISE_CHN_GROUP_S;
|
|
|
|
typedef struct {
|
|
struct list_head mIseGrpList; // element type: ISE_CHN_GROUP_MAP_S
|
|
pthread_mutex_t mIseGrpListLock;
|
|
} IseChnGroupManager;
|
|
|
|
IseChnGroupManager *gIseGrpMgr = NULL;
|
|
|
|
static ERRORTYPE addGroup(ISE_CHN_GROUP_S *pGroup)
|
|
{
|
|
pthread_mutex_lock(&gIseGrpMgr->mIseGrpListLock);
|
|
list_add_tail(&pGroup->mList, &gIseGrpMgr->mIseGrpList);
|
|
pthread_mutex_unlock(&gIseGrpMgr->mIseGrpListLock);
|
|
return SUCCESS;
|
|
}
|
|
|
|
static ERRORTYPE removeGroup(ISE_CHN_GROUP_S *pGroup)
|
|
{
|
|
pthread_mutex_lock(&gIseGrpMgr->mIseGrpListLock);
|
|
list_del(&pGroup->mList);
|
|
pthread_mutex_unlock(&gIseGrpMgr->mIseGrpListLock);
|
|
return SUCCESS;
|
|
}
|
|
|
|
static ISE_CHN_GROUP_S *ISE_CHN_GROUP_S_Construct()
|
|
{
|
|
ISE_CHN_GROUP_S *pGroup = (ISE_CHN_GROUP_S *)malloc(sizeof(ISE_CHN_GROUP_S));
|
|
if (NULL == pGroup) {
|
|
aloge("fatal error! malloc fail[%s]!", strerror(errno));
|
|
return NULL;
|
|
}
|
|
memset(pGroup, 0, sizeof(ISE_CHN_GROUP_S));
|
|
cdx_sem_init(&pGroup->mSemCompCmd, 0);
|
|
cdx_sem_init(&pGroup->mSemAddChn, 0);
|
|
cdx_sem_init(&pGroup->mSemRemoveChn, 0);
|
|
return pGroup;
|
|
}
|
|
|
|
static void ISE_CHN_GROUP_S_Destruct(ISE_CHN_GROUP_S *pGroup)
|
|
{
|
|
if (pGroup->mComp) {
|
|
aloge("fatal error! iseGroup component need free before!");
|
|
COMP_FreeHandle(pGroup->mComp);
|
|
pGroup->mComp = NULL;
|
|
}
|
|
cdx_sem_deinit(&pGroup->mSemCompCmd);
|
|
cdx_sem_deinit(&pGroup->mSemAddChn);
|
|
cdx_sem_deinit(&pGroup->mSemRemoveChn);
|
|
free(pGroup);
|
|
}
|
|
|
|
ERRORTYPE ISE_Construct(void)
|
|
{
|
|
ERRORTYPE eError = SUCCESS;
|
|
int ret;
|
|
if (gIseGrpMgr) {
|
|
alogw("mpi_ise module already create!");
|
|
return SUCCESS;
|
|
}
|
|
gIseGrpMgr = malloc(sizeof(IseChnGroupManager));
|
|
if (NULL == gIseGrpMgr) {
|
|
aloge("fatal error! malloc fail!");
|
|
return ERR_ISE_NULL_PTR;
|
|
}
|
|
INIT_LIST_HEAD(&gIseGrpMgr->mIseGrpList);
|
|
ret = pthread_mutex_init(&gIseGrpMgr->mIseGrpListLock, NULL);
|
|
if (ret != 0) {
|
|
aloge("fatal error! mutex init fail");
|
|
eError = ERR_ISE_NOMEM;
|
|
goto _err0;
|
|
}
|
|
return eError;
|
|
|
|
_err0:
|
|
free(gIseGrpMgr);
|
|
gIseGrpMgr = NULL;
|
|
return eError;
|
|
}
|
|
|
|
ERRORTYPE ISE_Destruct(void)
|
|
{
|
|
if (NULL == gIseGrpMgr) {
|
|
alogw("mpi_ise module already NULL!");
|
|
return SUCCESS;
|
|
}
|
|
pthread_mutex_lock(&gIseGrpMgr->mIseGrpListLock);
|
|
if (!list_empty(&gIseGrpMgr->mIseGrpList)) {
|
|
pthread_mutex_unlock(&gIseGrpMgr->mIseGrpListLock);
|
|
aloge("fatal error! ise channel group is not empty!");
|
|
return ERR_ISE_BUSY;
|
|
}
|
|
pthread_mutex_unlock(&gIseGrpMgr->mIseGrpListLock);
|
|
pthread_mutex_destroy(&gIseGrpMgr->mIseGrpListLock);
|
|
free(gIseGrpMgr);
|
|
gIseGrpMgr = NULL;
|
|
return SUCCESS;
|
|
}
|
|
|
|
MM_COMPONENTTYPE *ISE_GetGroupComp(MPP_CHN_S *pMppChn)
|
|
{
|
|
MM_COMPONENTTYPE *pComp = NULL;
|
|
ERRORTYPE ret = ERR_ISE_UNEXIST;
|
|
ISE_CHN_GROUP_S *pEntry;
|
|
pthread_mutex_lock(&gIseGrpMgr->mIseGrpListLock);
|
|
list_for_each_entry(pEntry, &gIseGrpMgr->mIseGrpList, mList)
|
|
{
|
|
if (pEntry->mIseGrp == pMppChn->mDevId) {
|
|
pComp = pEntry->mComp;
|
|
ret = SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&gIseGrpMgr->mIseGrpListLock);
|
|
return pComp;
|
|
}
|
|
|
|
static ERRORTYPE ISE_searchExistGroup(PARAM_IN ISE_GRP IseGrp, PARAM_OUT ISE_CHN_GROUP_S **ppGroup)
|
|
{
|
|
ERRORTYPE ret = ERR_ISE_UNEXIST;
|
|
ISE_CHN_GROUP_S *pEntry;
|
|
pthread_mutex_lock(&gIseGrpMgr->mIseGrpListLock);
|
|
list_for_each_entry(pEntry, &gIseGrpMgr->mIseGrpList, mList)
|
|
{
|
|
if (pEntry->mIseGrp == IseGrp) {
|
|
if (ppGroup) {
|
|
*ppGroup = pEntry;
|
|
}
|
|
ret = SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
pthread_mutex_unlock(&gIseGrpMgr->mIseGrpListLock);
|
|
return ret;
|
|
}
|
|
|
|
static ERRORTYPE VideoIseEventHandler(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 iseGroupInfo;
|
|
ret = ((MM_COMPONENTTYPE *)hComponent)->GetConfig(hComponent, COMP_IndexVendorMPPChannelInfo, &iseGroupInfo);
|
|
alogv("iseGroup comp event, iseGroupId[%d][%d][%d]", iseGroupInfo.mModId, iseGroupInfo.mDevId, iseGroupInfo.mChnId);
|
|
ISE_CHN_GROUP_S *pGrp = (ISE_CHN_GROUP_S *)pAppData;
|
|
|
|
switch (eEvent) {
|
|
case COMP_EventCmdComplete: {
|
|
if (COMP_CommandStateSet == nData1) {
|
|
// alogv("iseGroup EventCmdComplete, current StateSet[%d]", nData2);
|
|
cdx_sem_up(&pGrp->mSemCompCmd);
|
|
break;
|
|
} else if (COMP_CommandVendorAddChn == nData1) {
|
|
alogv("iseGroup EventCmdComplete, add chn done! result[0x%x]", nData2);
|
|
cdx_sem_up(&pGrp->mSemAddChn);
|
|
break;
|
|
} else if (COMP_CommandVendorRemoveChn == nData1) {
|
|
alogv("iseGroup EventCmdComplete, remove chn done! result[0x%x]", nData2);
|
|
cdx_sem_up(&pGrp->mSemRemoveChn);
|
|
break;
|
|
} else {
|
|
alogw("Low probability! what command[0x%x]?", nData1);
|
|
break;
|
|
}
|
|
}
|
|
case COMP_EventError: {
|
|
if (ERR_ISE_SAMESTATE == nData1) {
|
|
alogv("set same state to iseGroup!");
|
|
cdx_sem_up(&pGrp->mSemCompCmd);
|
|
break;
|
|
} else if (ERR_ISE_INVALIDSTATE == nData1) {
|
|
aloge("why iseGroup state turn to invalid?");
|
|
break;
|
|
} else if (ERR_ISE_INCORRECT_STATE_TRANSITION == nData1) {
|
|
aloge("fatal error! iseGroup state transition incorrect.");
|
|
break;
|
|
}
|
|
else if (ERR_ISE_ILLEGAL_PARAM == nData1) {
|
|
aloge("fatal error! invalid parameter.");
|
|
return ERR_ISE_ILLEGAL_PARAM;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
aloge("fatal error! unknown event error[0x%x]!", nData1);
|
|
break;
|
|
}
|
|
}
|
|
default:
|
|
aloge("fatal error! unknown event[0x%x]", eEvent);
|
|
break;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
ERRORTYPE VideoIseEmptyBufferDone(PARAM_IN COMP_HANDLETYPE hComponent, PARAM_IN void *pAppData,
|
|
PARAM_IN COMP_BUFFERHEADERTYPE *pBuffer)
|
|
{
|
|
|
|
#if 1
|
|
ISE_CHN_GROUP_S *pChn = (ISE_CHN_GROUP_S*)pAppData;
|
|
VIDEO_FRAME_INFO_S *pFrameInfo = (VIDEO_FRAME_INFO_S*)pBuffer->pAppPrivate;
|
|
unsigned int frameInfoPort = pBuffer->nFlags;
|
|
MPP_CHN_S ChannelInfo;
|
|
ChannelInfo.mModId = MOD_ID_ISE;
|
|
ChannelInfo.mDevId = 0;
|
|
// ChannelInfo.mChnId = pChn->mIseChn;
|
|
CHECK_MPP_CALLBACK(pChn->mCallbackInfo.callback);
|
|
if (0 == frameInfoPort) {/* ISE_PORT_INDEX_CAP0_IN == 0*/
|
|
pChn->mCallbackInfo.callback(pChn->mCallbackInfo.cookie, &ChannelInfo,
|
|
MPP_EVENT_RELEASE_ISE_VIDEO_BUFFER0, (void*)pFrameInfo);
|
|
} else if (1 == frameInfoPort) {/* ISE_PORT_INDEX_CAP1_IN == 1*/
|
|
pChn->mCallbackInfo.callback(pChn->mCallbackInfo.cookie, &ChannelInfo,
|
|
MPP_EVENT_RELEASE_ISE_VIDEO_BUFFER1, (void*)pFrameInfo);
|
|
}
|
|
#endif
|
|
return SUCCESS;
|
|
}
|
|
|
|
COMP_CALLBACKTYPE VideoIseCallback = {
|
|
.EventHandler = VideoIseEventHandler, .EmptyBufferDone = VideoIseEmptyBufferDone, .FillBufferDone = NULL,
|
|
};
|
|
|
|
ERRORTYPE AW_MPI_ISE_CreateGroup(ISE_GRP IseGrp, ISE_GROUP_ATTR_S *pGrpAttr)
|
|
{
|
|
if (!((IseGrp >= 0) && (IseGrp < ISE_MAX_GRP_NUM))) {
|
|
aloge("fatal error! invalid IseGrp[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
if (NULL == pGrpAttr) {
|
|
aloge("fatal error! illagal IseAttr!");
|
|
return ERR_ISE_ILLEGAL_PARAM;
|
|
}
|
|
if (SUCCESS == ISE_searchExistGroup(IseGrp, NULL)) {
|
|
return ERR_ISE_EXIST;
|
|
}
|
|
ISE_CHN_GROUP_S *pNode = ISE_CHN_GROUP_S_Construct();
|
|
pNode->mIseGrp = IseGrp;
|
|
|
|
// create iseGroup Component here...
|
|
ERRORTYPE eRet = SUCCESS;
|
|
eRet = COMP_GetHandle((COMP_HANDLETYPE *)&pNode->mComp, CDX_ComponentNameISE, (void *)pNode, &VideoIseCallback);
|
|
MPP_CHN_S ChannelInfo;
|
|
ChannelInfo.mModId = MOD_ID_ISE;
|
|
ChannelInfo.mDevId = 0;
|
|
ChannelInfo.mChnId = pNode->mIseGrp;
|
|
eRet = pNode->mComp->SetConfig(pNode->mComp, COMP_IndexVendorMPPChannelInfo, (void *)&ChannelInfo);
|
|
eRet = pNode->mComp->SetConfig(pNode->mComp, COMP_IndexVendorIseGroupAttr, (void *)pGrpAttr);
|
|
eRet = pNode->mComp->SendCommand(pNode->mComp, COMP_CommandStateSet, COMP_StateIdle, NULL);
|
|
cdx_sem_down(&pNode->mSemCompCmd);
|
|
// create iseGroup Component done!
|
|
|
|
addGroup(pNode);
|
|
return SUCCESS;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_DestroyGroup(ISE_GRP IseGrp)
|
|
{
|
|
ERRORTYPE ret;
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid IseGrp[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE eRet;
|
|
if (pGrp->mComp) {
|
|
COMP_STATETYPE nCompState;
|
|
if (SUCCESS == pGrp->mComp->GetState(pGrp->mComp, &nCompState)) {
|
|
if (nCompState == COMP_StateIdle) {
|
|
eRet = pGrp->mComp->SendCommand(pGrp->mComp, COMP_CommandStateSet, COMP_StateLoaded, NULL);
|
|
cdx_sem_down(&pGrp->mSemCompCmd);
|
|
if (eRet != SUCCESS) {
|
|
aloge("fatal error! why transmit state to loaded fail?");
|
|
}
|
|
} else if (nCompState == COMP_StateLoaded) {
|
|
eRet = SUCCESS;
|
|
} else if (nCompState == COMP_StateInvalid) {
|
|
alogw("Low probability! Component StateInvalid?");
|
|
eRet = SUCCESS;
|
|
} else {
|
|
aloge("fatal error! invalid VeChn[%d] state[0x%x]!", IseGrp, nCompState);
|
|
eRet = ERR_ISE_INCORRECT_STATE_OPERATION;
|
|
}
|
|
|
|
if (eRet == SUCCESS) {
|
|
removeGroup(pGrp);
|
|
COMP_FreeHandle(pGrp->mComp);
|
|
pGrp->mComp = NULL;
|
|
ISE_CHN_GROUP_S_Destruct(pGrp);
|
|
}
|
|
ret = eRet;
|
|
} else {
|
|
aloge("fatal error! GetState fail!");
|
|
ret = ERR_ISE_BUSY;
|
|
}
|
|
} else {
|
|
aloge("fatal error! no iseGroup component!");
|
|
list_del(&pGrp->mList);
|
|
ISE_CHN_GROUP_S_Destruct(pGrp);
|
|
ret = SUCCESS;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_GetGrpAttr(ISE_GRP IseGrp, ISE_GROUP_ATTR_S *pGrpAttr)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
ret = pGrp->mComp->GetConfig(pGrp->mComp, COMP_IndexVendorIseGroupAttr, (void *)pGrpAttr);
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_SetGrpAttr(ISE_GRP IseGrp, ISE_GROUP_ATTR_S *pGrpAttr)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
ret = pGrp->mComp->SetConfig(pGrp->mComp, COMP_IndexVendorIseGroupAttr, (void *)pGrpAttr);
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_CreatePort(ISE_GRP IseGrp, ISE_CHN IsePort, ISE_CHN_ATTR_S *pChnAttr)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
|
|
if (!(IsePort >= 0 && IsePort < ISE_MAX_CHN_NUM)) {
|
|
aloge("fatal error! invalid IsePort[%d]!", IsePort);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
IseChnAttr chnAttr;
|
|
memset(&chnAttr, 0, sizeof(IseChnAttr));
|
|
chnAttr.mGrpId = IseGrp;
|
|
chnAttr.mChnId = IsePort;
|
|
|
|
ret = pGrp->mComp->GetConfig(pGrp->mComp, COMP_IndexVendorIseChnAttr, &chnAttr); // get default attr
|
|
|
|
if (ERR_ISE_UNEXIST == ret) {
|
|
chnAttr.pChnAttr = pChnAttr;
|
|
// ret = pGrp->mComp->SendCommand(pGrp->mComp, COMP_CommandVendorAddChn, 0, &chnAttr);
|
|
// cdx_sem_down(&pGrp->mSemAddChn);
|
|
ret = pGrp->mComp->SetConfig(pGrp->mComp, COMP_IndexVendorIseAddChn, &chnAttr);
|
|
return ret;
|
|
} else if (SUCCESS == ret) {
|
|
alogd("iseChn[%d] of group[%d] is exist!", IsePort, IseGrp);
|
|
return ERR_ISE_EXIST;
|
|
} else {
|
|
aloge("fatal error! add chn[%d] of group[%d] fail[0x%x]!", IsePort, IseGrp, ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_DestroyPort(ISE_GRP IseGrp, ISE_CHN IsePort)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
if (!(IsePort >= 0 && IsePort < ISE_MAX_CHN_NUM)) {
|
|
aloge("fatal error! invalid IsePort[%d]!", IsePort);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
IseChnAttr chnAttr;
|
|
memset(&chnAttr, 0, sizeof(IseChnAttr));
|
|
chnAttr.mGrpId = IseGrp;
|
|
chnAttr.mChnId = IsePort;
|
|
chnAttr.pChnAttr = NULL;
|
|
ret = pGrp->mComp->GetConfig(pGrp->mComp, COMP_IndexVendorIseChnAttr, &chnAttr);
|
|
if (SUCCESS == ret) {
|
|
// ret = pGrp->mComp->SendCommand(pGrp->mComp, COMP_CommandVendorRemoveChn, IsePort, &chnAttr);
|
|
// cdx_sem_down(&pGrp->mSemRemoveChn);
|
|
ret = pGrp->mComp->SetConfig(pGrp->mComp, COMP_IndexVendorIseRemoveChn, &chnAttr);
|
|
return ret;
|
|
} else if (ERR_ISE_UNEXIST == ret) {
|
|
alogd("iseChn[%d] of group[%d] is unexist!", IsePort, IseGrp);
|
|
return ERR_ISE_UNEXIST;
|
|
} else {
|
|
aloge("fatal error! remove chn[%d] of group[%d] fail[0x%x]!", IsePort, IseGrp, ret);
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_GetPortAttr(ISE_GRP IseGrp, ISE_CHN IsePort, ISE_CHN_ATTR_S *pChnAttr)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
if (!(IsePort >= 0 && IsePort < ISE_MAX_CHN_NUM)) {
|
|
aloge("fatal error! invalid IsePort[%d]!", IsePort);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
IseChnAttr chnAttr;
|
|
memset(&chnAttr, 0, sizeof(IseChnAttr));
|
|
chnAttr.mGrpId = IseGrp;
|
|
chnAttr.mChnId = IsePort;
|
|
chnAttr.pChnAttr = pChnAttr;
|
|
ret = pGrp->mComp->GetConfig(pGrp->mComp, COMP_IndexVendorIseChnAttr, &chnAttr);
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_SetPortAttr(ISE_GRP IseGrp, ISE_CHN IsePort, ISE_CHN_ATTR_S *pChnAttr)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
if (!(IsePort >= 0 && IsePort < ISE_MAX_CHN_NUM)) {
|
|
aloge("fatal error! invalid IsePort[%d]!", IsePort);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
IseChnAttr chnAttr;
|
|
memset(&chnAttr, 0, sizeof(IseChnAttr));
|
|
chnAttr.mGrpId = IseGrp;
|
|
chnAttr.mChnId = IsePort;
|
|
chnAttr.pChnAttr = pChnAttr;
|
|
ret = pGrp->mComp->SetConfig(pGrp->mComp, COMP_IndexVendorIseChnAttr, &chnAttr);
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_Start(ISE_GRP IseGrp)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
int ret;
|
|
int eRet;
|
|
COMP_STATETYPE nCompState;
|
|
eRet = pGrp->mComp->GetState(pGrp->mComp, &nCompState);
|
|
if (COMP_StateIdle == nCompState) {
|
|
eRet = pGrp->mComp->SendCommand(pGrp->mComp, COMP_CommandStateSet, COMP_StateExecuting, NULL);
|
|
cdx_sem_down(&pGrp->mSemCompCmd);
|
|
ret = SUCCESS;
|
|
} else {
|
|
alogd("iseGroup comp state[0x%x], do nothing!", nCompState);
|
|
ret = SUCCESS;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_Stop(ISE_GRP IseGrp)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid iseGroup[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
int eError;
|
|
int eRet;
|
|
COMP_STATETYPE nCompState;
|
|
eRet = pGrp->mComp->GetState(pGrp->mComp, &nCompState);
|
|
if (COMP_StateExecuting == nCompState || COMP_StatePause == nCompState) {
|
|
eRet = pGrp->mComp->SendCommand(pGrp->mComp, COMP_CommandStateSet, COMP_StateIdle, NULL);
|
|
cdx_sem_down(&pGrp->mSemCompCmd);
|
|
eError = eRet;
|
|
} else if (COMP_StateIdle == nCompState) {
|
|
alogv("iseGroup comp state[0x%x], do nothing!", nCompState);
|
|
eError = SUCCESS;
|
|
} else {
|
|
aloge("fatal error! check iseGroup state[0x%x]!", nCompState);
|
|
eError = SUCCESS;
|
|
}
|
|
return eError;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_GetData(ISE_GRP IseGrp, ISE_CHN IsePort, VIDEO_FRAME_INFO_S *pstIseData, AW_S32 s32MilliSec)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid IseGrp[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
if (!(IsePort >= 0 && IsePort < ISE_MAX_CHN_NUM)) {
|
|
aloge("fatal error! invalid IsePort[%d]!", IsePort);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret = -1;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
ISE_DATA_S iseData;
|
|
iseData.mIseGrp = IseGrp;
|
|
iseData.mIseChn = IsePort;
|
|
iseData.nMilliSec = s32MilliSec;
|
|
iseData.frame = pstIseData;
|
|
|
|
ret = pGrp->mComp->GetConfig(pGrp->mComp, COMP_IndexVendorGetIseData, (void *)&iseData);
|
|
return ret;
|
|
}
|
|
ERRORTYPE AW_MPI_ISE_ReleaseData(ISE_GRP IseGrp, ISE_CHN IsePort, VIDEO_FRAME_INFO_S *pstIseData)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid IseGrp[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
if (!(IsePort >= 0 && IsePort < ISE_MAX_CHN_NUM)) {
|
|
aloge("fatal error! invalid IsePort[%d]!", IsePort);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
ISE_DATA_S iseData;
|
|
iseData.mIseGrp = IseGrp;
|
|
iseData.mIseChn = IsePort;
|
|
iseData.frame = pstIseData;
|
|
ret = pGrp->mComp->SetConfig(pGrp->mComp, COMP_IndexVendorReleaseIseData, (void *)&iseData);
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_SendPic(ISE_GRP IseGrp, VIDEO_FRAME_INFO_S *pstUserFrame0, VIDEO_FRAME_INFO_S *pstUserFrame1,
|
|
AW_S32 s32MilliSec)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid VeChn[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if (COMP_StateExecuting != nState && COMP_StateIdle != nState) {
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
COMP_BUFFERHEADERTYPE bufferHeader;
|
|
bufferHeader.pAppPrivate = (void *)pstUserFrame0; // camera0
|
|
bufferHeader.pPlatformPrivate = (void *)pstUserFrame1; // camera1
|
|
ret = pGrp->mComp->EmptyThisBuffer(pGrp->mComp, &bufferHeader);
|
|
|
|
return ret;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_RegisterCallback(ISE_GRP IseGrp, MPPCallbackInfo *pCallback)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid IseGrp[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
pGrp->mCallbackInfo.callback = pCallback->callback;
|
|
pGrp->mCallbackInfo.cookie = pCallback->cookie;
|
|
return SUCCESS;
|
|
}
|
|
|
|
ERRORTYPE AW_MPI_ISE_SetISEFreq(ISE_GRP IseGrp, int nFreq)
|
|
{
|
|
if (!(IseGrp >= 0 && IseGrp < ISE_MAX_GRP_NUM)) {
|
|
aloge("fatal error! invalid IseGrp[%d]!", IseGrp);
|
|
return ERR_ISE_INVALID_CHNID;
|
|
}
|
|
ISE_CHN_GROUP_S *pGrp;
|
|
if (SUCCESS != ISE_searchExistGroup(IseGrp, &pGrp)) {
|
|
return ERR_ISE_UNEXIST;
|
|
}
|
|
int ISEFreq = nFreq;
|
|
if(ISEFreq != 300)
|
|
{
|
|
aloge("fatal error! invalid frequency %dM",ISEFreq);
|
|
return ERR_ISE_ILLEGAL_PARAM;
|
|
}
|
|
|
|
ERRORTYPE ret;
|
|
COMP_STATETYPE nState;
|
|
ret = pGrp->mComp->GetState(pGrp->mComp, &nState);
|
|
if(COMP_StateExecuting != nState && COMP_StateIdle != nState)
|
|
{
|
|
aloge("wrong state[0x%x], return!", nState);
|
|
return ERR_ISE_NOT_PERM;
|
|
}
|
|
ret = pGrp->mComp->SetConfig(pGrp->mComp, COMP_IndexVendorIseFreq, (void*)&ISEFreq);
|
|
return ret;
|
|
}
|
|
|