int ALG_vidEncDelete(void *hndl)
{
ALG_VidEncObj *pObj=(ALG_VidEncObj *)hndl;
if(pObj==NULL)
return OSA_EFAIL;
if(pObj->createPrm.codec==ALG_VID_CODEC_MJPEG)
{
ALG_jpgEncDelete(pObj->hJpgEncode);
}
else {
if(pObj->hEncode)
{
if( pObj->MV_Size != 0 )
{
OSA_cmemFree(pObj->MV_Addr);
}
VIDENC1_delete(pObj->hEncode);
}
}
OSA_memFree(pObj);
return OSA_SOK;
}
/* ========================================================================== */
int OSA_EventDelete(OSA_PTR pEvents)
{
int bReturnStatus = OSA_SOK;
OSA_THREAD_EVENT *plEvent = (OSA_THREAD_EVENT *)pEvents;
if(0 == plEvent){
bReturnStatus = OSA_EFAIL;
goto EXIT;
}
if(0 != pthread_mutex_lock(&(plEvent->mutex))) {
/*OSAL_ERROR("Event Delete: Mutex Lock failed !");*/
bReturnStatus = OSA_EFAIL;
}
if(0 != pthread_cond_destroy(&(plEvent->condition))){
/*OSAL_ERROR("Event Delete: Conditional Variable Destroy failed !");*/
bReturnStatus = OSA_EFAIL;
}
if(0 != pthread_mutex_unlock(&(plEvent->mutex))) {
/*OSAL_ERROR("Event Delete: Mutex Unlock failed !");*/
bReturnStatus = OSA_EFAIL;
}
if(0 != pthread_mutex_destroy(&(plEvent->mutex))) {
/*OSAL_ERROR("Event Delete: Mutex Destory failed !");*/
bReturnStatus = OSA_EFAIL;
}
OSA_memFree(plEvent);
EXIT:
return bReturnStatus;
}
/* ========================================================================== */
int OSA_EventCreate(OSA_PTR *pEvents)
{
int bReturnStatus = OSA_EFAIL;
OSA_THREAD_EVENT *plEvent = NULL;
plEvent = (OSA_THREAD_EVENT *)OSA_memAlloc(sizeof(OSA_THREAD_EVENT));
if(0 == plEvent) {
bReturnStatus = OSA_EFAIL;
goto EXIT;
}
plEvent->bSignaled = 0;
plEvent->eFlags = 0;
if(0 != pthread_mutex_init(&(plEvent->mutex), NULL)){
/*OSA_ERROR("Event Create:Mutex Init failed !");*/
goto EXIT; /*bReturnStatus = TIMM_OSAL_ERR_UNKNOWN*/
}
if(0 != pthread_cond_init(&(plEvent->condition), NULL)){
/*TIMM_OSAL_Error("Event Create:Conditional Variable Init failed !");*/
pthread_mutex_destroy(&(plEvent->mutex));
/*TIMM_OSAL_Free(plEvent);*/
}
else {
*pEvents = (OSA_PTR)plEvent;
bReturnStatus = OSA_SOK;
}
EXIT:
if ((OSA_SOK != bReturnStatus) && (0 != plEvent)) {
OSA_memFree(plEvent);
}
return bReturnStatus;
}
int OSA_queDelete(OSA_QueHndl *hndl)
{
if(hndl->queue!=NULL)
OSA_memFree(hndl->queue);
pthread_cond_destroy(&hndl->condRd);
pthread_cond_destroy(&hndl->condWr);
pthread_mutex_destroy(&hndl->lock);
return OSA_SOK;
}
int OSA_mbxFreeMsg(OSA_MsgHndl *pMsg)
{
if(pMsg->flags & OSA_MBX_FREE_PRM) {
if(pMsg->pPrm!=NULL) {
OSA_memFree(pMsg->pPrm);
}
}
OSA_assertSuccess( OSA_msgqFreeMsgHndl(pMsg) );
return OSA_SOK;
}
int ALG_jpgDecDelete(void *hndl)
{
ALG_JpgDecObj *pObj=(ALG_JpgDecObj *)hndl;
if(pObj==NULL)
return OSA_EFAIL;
if(pObj->hDecode)
IMGDEC1_delete(pObj->hDecode);
OSA_memFree(pObj);
return OSA_SOK;
}
void *ALG_jpgEncCreate(ALG_JpgEncCreate *create)
{
ALG_JpgEncObj *pObj;
XDAS_Int32 status;
if(gALG_hEngine==NULL)
return NULL;
pObj = OSA_memAlloc(sizeof(ALG_JpgEncObj));
if(pObj==NULL)
return NULL;
memset(pObj, 0, sizeof(*pObj));
strcpy(pObj->algName, ALG_VID_CODEC_JPEG_ENC_NAME);
memcpy(&pObj->createPrm, create, sizeof(pObj->createPrm));
pObj->params.size = sizeof(IMGENC1_Params);
pObj->params.maxHeight = create->height;
pObj->params.maxWidth = pObj->createPrm.offsetH>create->width?pObj->createPrm.offsetH:create->width;
pObj->params.maxScans = 1;
pObj->params.dataEndianness = XDM_BYTE;
if(create->encDataFormat==ALG_VID_DATA_FORMAT_YUV422)
pObj->params.forceChromaFormat = XDM_YUV_422P;
else
pObj->params.forceChromaFormat = XDM_YUV_420P;
pObj->hEncode = IMGENC1_create(gALG_hEngine, pObj->algName, &pObj->params);
if (pObj->hEncode == NULL) {
OSA_ERROR("Failed to open video encode algorithm: %s (0x%x)\n", pObj->algName, Engine_getLastError(gALG_hEngine));
OSA_memFree(pObj);
return NULL;
}
status = ALG_jpgEncSetQvalue(pObj, create->qValue);
if(status!=OSA_SOK) {
ALG_jpgEncDelete(pObj);
return NULL;
}
return pObj;
}
status_t thread_delete(thread_t *pthd)
{
status_t status = OSA_SOK;
struct __thread_t * thd = (struct __thread_t *)(*pthd);
DBG(DBG_DETAILED, GT_NAME, "thread_delete: Enter (pthd=0x%x).\n", thd);
thread_check_arguments2(pthd, thd);
unsigned short cancel = (thd->thd_status == 0);
if (((thread_t)thd) != thread_self()) {
if (cancel) {
int r;
r = pthread_cancel(thd->thd_id);
r = pthread_join(thd->thd_id, NULL);
}
}
/*
* Modified by: xiong-kaifang.
*
* Date : Aug 22, 2015.
*
* Description:
*
* Destroy thread attributes object.
*
*/
pthread_attr_destroy(&thd->pattrs);
status |= OSA_memFree(sizeof(struct __thread_t), thd);
(*pthd) = INVALID_HANDLE;
DBG(DBG_DETAILED, GT_NAME, "thread_delete: Exit.\n");
return status;
}
void *ALG_jpgDecCreate(ALG_JpgDecCreate *create)
{
ALG_JpgDecObj *pObj;
if(gALG_hEngine==NULL)
return NULL;
pObj = OSA_memAlloc(sizeof(ALG_JpgDecObj));
if(pObj==NULL)
return NULL;
memset(pObj, 0, sizeof(*pObj));
strcpy(pObj->algName, ALG_VID_CODEC_JPEG_DEC_NAME);
memcpy(&pObj->createPrm, create, sizeof(pObj->createPrm));
pObj->params.size = sizeof(pObj->params);
pObj->params.maxHeight = create->maxHeight;
pObj->params.maxWidth = create->maxWidth;
pObj->params.maxScans = 1;
pObj->params.dataEndianness = XDM_BYTE;
if(create->dataFormat==ALG_VID_DATA_FORMAT_YUV422)
pObj->params.forceChromaFormat = XDM_YUV_422ILE;
else
pObj->params.forceChromaFormat = XDM_YUV_420SP;
pObj->hDecode = IMGDEC1_create(gALG_hEngine, pObj->algName, &pObj->params);
if (pObj->hDecode == NULL) {
OSA_ERROR("Failed to open image decode algorithm: %s (0x%x)\n", pObj->algName, Engine_getLastError(gALG_hEngine));
OSA_memFree(pObj);
return NULL;
}
return pObj;
}
void *ALG_vidEncCreate(ALG_VidEncCreate *create)
{
XDAS_Int32 status;
ALG_VidEncObj *pObj;
if(gALG_hEngine==NULL)
return NULL;
pObj = OSA_memAlloc(sizeof(ALG_VidEncObj));
if(pObj==NULL)
return NULL;
memset(pObj, 0, sizeof(ALG_VidEncObj));
switch(create->codec) {
case ALG_VID_CODEC_H264:
strcpy(pObj->algName, ALG_VID_CODEC_H264_ENC_NAME);
break;
case ALG_VID_CODEC_MPEG4:
strcpy(pObj->algName, ALG_VID_CODEC_MPEG4_ENC_NAME);
break;
case ALG_VID_CODEC_MJPEG:
strcpy(pObj->algName, ALG_VID_CODEC_JPEG_ENC_NAME);
break;
default:
OSA_memFree(pObj);
return NULL;
}
memcpy(&pObj->createPrm, create, sizeof(pObj->createPrm));
if(create->codec==ALG_VID_CODEC_MJPEG)
{
ALG_JpgEncCreate jpgCreate;
jpgCreate.dataFormat = create->dataFormat;
jpgCreate.width = create->width;
jpgCreate.height = create->height;
jpgCreate.offsetH = create->offsetH;
jpgCreate.offsetV = create->offsetV;
jpgCreate.encDataFormat = ALG_VID_DATA_FORMAT_YUV420;
jpgCreate.qValue = create->qValue;
pObj->hJpgEncode = ALG_jpgEncCreate(&jpgCreate);
if(pObj->hJpgEncode==NULL) {
OSA_memFree(pObj);
return NULL;
}
return pObj;
}
pObj->params.maxHeight = create->height;
pObj->params.maxWidth = create->width;
pObj->params.maxFrameRate = ALD_VID_ENC_MAX_FRAMERATE;
pObj->params.maxBitRate = ALD_VID_ENC_MAX_BITRATE;
pObj->params.inputChromaFormat = XDM_YUV_420SP;
pObj->params.dataEndianness = XDM_BYTE;
pObj->params.maxInterFrameInterval = 1;
pObj->params.inputContentType = IVIDEO_PROGRESSIVE;
pObj->params.reconChromaFormat = XDM_YUV_420SP;
if(create->codec==ALG_VID_CODEC_MPEG4)
{
pObj->params.size = sizeof(IMP4VENC_Params);
pObj->params.encodingPreset = XDM_USER_DEFINED;
pObj->params.maxHeight = create->height;
pObj->params.maxWidth = (create->offsetH>create->width)?create->offsetH:create->width;
pObj->params_mpeg4.subWindowHeight = create->height;
pObj->params_mpeg4.subWindowWidth = create->width;
pObj->params_mpeg4.rotation = 0;
pObj->params_mpeg4.vbvSize = 0;
pObj->params_mpeg4.svhMode = 0;
pObj->params_mpeg4.IFrameBitRateBiasFactor = 256;
pObj->params_mpeg4.PFrameBitRateBiasFactor = 256;
pObj->params_mpeg4.peakBufWindow = 2;
pObj->params_mpeg4.minBitRate = 64000; //set to 64kbps
switch(create->rateControlType) {
case ALG_VID_ENC_RATE_CONTROL_RCOFF:
pObj->params.rateControlPreset = IVIDEO_NONE;
break;
default:
case ALG_VID_ENC_RATE_CONTROL_VBR:
pObj->params.rateControlPreset = IVIDEO_STORAGE;
break;
case ALG_VID_ENC_RATE_CONTROL_CBR:
pObj->params.rateControlPreset = IVIDEO_LOW_DELAY;
break;
}
}
else if(create->codec==ALG_VID_CODEC_H264)
{
if(77 == create->profileIdc)
{
pObj->params_h264.profileIdc = 77;
pObj->params_h264.transform8x8FlagIntraFrame = 0;
pObj->params_h264.transform8x8FlagInterFrame = 0;
pObj->params_h264.seqScalingFlag = 0;
pObj->params_h264.entropyMode = 1;
printf("[alg_vidEnc]zeng Main profile --------------create->profileIdc=%d\n" , create->profileIdc);
}
else if(66 == create->profileIdc)
{
pObj->params_h264.profileIdc = 66;
pObj->params_h264.transform8x8FlagIntraFrame = 0;
pObj->params_h264.transform8x8FlagInterFrame = 0;
pObj->params_h264.seqScalingFlag = 0;
pObj->params_h264.entropyMode = 0;
printf("[alg_vidEnc]zeng baseline profile--------------create->profileIdc=%d\n" , create->profileIdc);
}
else
{
pObj->params_h264.profileIdc = 100;
pObj->params_h264.transform8x8FlagIntraFrame = 0;
pObj->params_h264.transform8x8FlagInterFrame = (create->width>2048)?0:1;
pObj->params_h264.seqScalingFlag = 1;
pObj->params_h264.entropyMode = 1;
printf("[alg_vidEnc]zeng hight profile--------------create->profileIdc=%d\n" , create->profileIdc);
}
pObj->params.size = sizeof(IH264VENC_Params);
pObj->params.rateControlPreset = IVIDEO_USER_DEFINED;
pObj->params_h264.levelIdc = IH264VENC_LEVEL_40;
pObj->params_h264.Log2MaxFrameNumMinus4 = 0;
pObj->params_h264.ConstraintSetFlag = 0;
pObj->params_h264.enableVUIparams = 7;
pObj->params_h264.meAlgo = 0;
pObj->params_h264.enableARM926Tcm = 0;
pObj->params_h264.enableDDRbuff = (create->ddrEnable) ? 1 : 0;
pObj->params_h264.sliceMode = 3;
pObj->params_h264.EnableLongTermFrame = 0;
pObj->params_h264.outputDataMode = IH264VENC_TI_ENTIREFRAME;
pObj->params_h264.sliceFormat = IH264VENC_TI_BYTESTREAM;
printf("[alg_vidEnc]zeng afdfafdasfdasf--------create->profileIdc=%d\n" , create->profileIdc);
if((create->encodePreset&ALG_VID_ENC_PRESET_MASK) == ALG_VID_ENC_PRESET_AUTO)
{
if((create->width<320)||(create->height<128))
{
pObj->params.encodingPreset = XDM_USER_DEFINED;
pObj->params_h264.encQuality = 0;
}
else {
if(create->mode == ALG_VID_ENC_MODE_STANDARD) {
pObj->params.encodingPreset = XDM_HIGH_QUALITY;
pObj->params_h264.encQuality = 2;
}
else {
pObj->params.encodingPreset = XDM_HIGH_SPEED;
pObj->params_h264.encQuality = 3;
}
}
}
else {
pObj->params.encodingPreset = XDM_USER_DEFINED;
pObj->params_h264.encQuality = 0;
}
if((create->encodePreset&ALG_VID_ENC_SVC_MASK) == ALG_VID_ENC_PRESET_SVC)
{
pObj->params_h264.numTemporalLayers = 3;
pObj->params_h264.svcSyntaxEnable = XDAS_FALSE;
/*
To disable svcSyntaxEnable as most player cant play this SVC syntax,
if player is comptatible, please change the value to XDAS_TRUE;
*/
}
else {
pObj->params_h264.numTemporalLayers = 0;
pObj->params_h264.svcSyntaxEnable = XDAS_FALSE;
}
}
/*enable mv when initialize for get memory information*/
pObj->createPrm.mbMvOutEnable = 1;
pObj->createPrm.forceKeyFrame = FALSE;
/* Create video encoder instance */
pObj->hEncode = VIDENC1_create(gALG_hEngine, pObj->algName, &pObj->params);
if (pObj->hEncode == NULL) {
OSA_ERROR("Failed to open video encode algorithm: %s (0x%x)\n", pObj->algName, Engine_getLastError(gALG_hEngine));
OSA_memFree(pObj);
return NULL;
}
status = ALG_vidEncSetDynamicParams(pObj);
if(status!=OSA_SOK) {
ALG_vidEncDelete(pObj);
return NULL;
}
return pObj;
}
int IMAGE_TUNE_LoadParams(int paramSetId)
{
int retVal = OSA_EFAIL;
Uint32 readSize = 0, pID = 0;
#ifdef IMAGE_TUNE_MULTI_PARAM
IMAGE_TUNE_ParamSetList *pPrmList;
#if 0
if(gImageTunePrmList != NULL) {
pPrmList = gImageTunePrmList;
retVal = OSA_fileReadFile(IMAGE_TUNE_PARAMSET_DIR, (Uint8*)pPrmList, sizeof(IMAGE_TUNE_ParamSetList), &readSize);
if(retVal != OSA_SOK || readSize!=sizeof(IMAGE_TUNE_ParamSetList)) {
OSA_printf(" IMAGE TUNE:PId %d; ParamSet Size: %d, Size %d; Set default paramset !!!\n", paramSetId, sizeof(IMAGE_TUNE_ParamSetList), readSize);
retVal = OSA_EFAIL;
return retVal;
}
}
#endif
if(gImageTunePrmList != NULL) {
pPrmList = gImageTunePrmList;
//pID = pPrmList->curParamset; /* Getting Parameter set ID from NAND */
//OSA_printf(" IMAGE TUNE: param set ID: %d read from NAND!\n", pID);
pID = paramSetId;
if( pID <= IMAGE_TUNE_DEFAULT_PARAMSET || pID >= IMAGE_TUNE_MAX_PARAMSET || pPrmList->paramFlag[pID]!= pID){
OSA_printf(" IMAGE TUNE: Param set ID: %d, ParamFlag: %d ; default(0) / wrong param set!!!\n", pID, pPrmList->paramFlag[pID]);
//if( pID <= IMAGE_TUNE_DEFAULT_PARAMSET || pID >= IMAGE_TUNE_MAX_PARAMSET ){
//OSA_printf(" IMAGE TUNE: Param set ID: %d ; default(0) / pPrmList->paramFlag[pID] %d wrong param set!!!\n", pID,0);
//gCurPrmSet = IMAGE_TUNE_DEFAULT_PARAMSET;
retVal = OSA_EFAIL;
return retVal;
}
memcpy(&gIMAGE_TUNE_ctrl.curPrm.ccdcPrm, &pPrmList->paramSet[pID].ccdcPrm, sizeof(IMAGE_TUNE_CcdcParams_m));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.ccdcPrm.lscGainTable, &pPrmList->ccdcTable.lscGainTable, sizeof(pPrmList->ccdcTable.lscGainTable));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.ccdcPrm.lscOffsetTable, &pPrmList->ccdcTable.lscOffsetTable, sizeof(pPrmList->ccdcTable.lscOffsetTable));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.ipipeifPrm, &pPrmList->paramSet[pID].ipipeifPrm, sizeof(IMAGE_TUNE_IpipeifParams));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.ipipePrm, &pPrmList->paramSet[pID].ipipePrm, sizeof(IMAGE_TUNE_IpipeParams));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.ldcPrm, &pPrmList->paramSet[pID].ldcPrm, sizeof(IMAGE_TUNE_LdcParams));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.vnfPrm, &pPrmList->paramSet[pID].vnfPrm, sizeof(ALG_vnfParams));
memcpy(&gIMAGE_TUNE_ctrl.curPrm.awbPrm, &pPrmList->paramSet[pID].awbPrm, sizeof(awb_calc_data_t));
OSA_printf(" IMAGE TUNE: param set ID:%d updated!!!\n", pID);
#if 0 //debug
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.ccdcPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.ccdcPrm), &gIMAGE_TUNE_ctrl.curPrm.ccdcPrm);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.ccdcPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.ccdcPrm.lscGainTable), &gIMAGE_TUNE_ctrl.curPrm.ccdcPrm.lscGainTable);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.ccdcPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.ccdcPrm.lscOffsetTable), &gIMAGE_TUNE_ctrl.curPrm.ccdcPrm.lscOffsetTable);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.ipipeifPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.ipipeifPrm), &gIMAGE_TUNE_ctrl.curPrm.ipipeifPrm);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.ipipePrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.ipipePrm), &gIMAGE_TUNE_ctrl.curPrm.ipipePrm);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.ldcPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.ldcPrm), &gIMAGE_TUNE_ctrl.curPrm.ldcPrm);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.vnfPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.vnfPrm), &gIMAGE_TUNE_ctrl.curPrm.vnfPrm);
OSA_printf(" gIMAGE_TUNE_ctrl.curPrm.awbPrm %d, %p \n", sizeof(gIMAGE_TUNE_ctrl.curPrm.awbPrm), &gIMAGE_TUNE_ctrl.curPrm.awbPrm);
OSA_printf(" \r\n gIMAGE_TUNE_ctrl.curPrm.ipipePrm %d, %d, %d ", gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv.matrix[0][0],gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv.matrix[1][1], gIMAGE_TUNE_ctrl.curPrm.ipipePrm.rgb2yuv.offset[0]);
#endif
retVal = OSA_SOK;
}
#else
char filename[64];
IMAGE_TUNE_ParamSet *pTmpPrmSet;
int checkSum = 0 ;
if(paramSetId>99) {
return OSA_SOK;
}
pTmpPrmSet = (IMAGE_TUNE_ParamSet *)OSA_memAlloc(sizeof(IMAGE_TUNE_ParamSet));
sprintf(filename, "%s/IMGPRM%02d.BIN", IMAGE_TUNE_PARAM_STORAGE_FILE_PATH, paramSetId);
retVal = OSA_fileReadFile(filename, (Uint8*)pTmpPrmSet, sizeof(IMAGE_TUNE_ParamSet),0, &readSize);
if(retVal!=OSA_SOK) {
goto error_exit;
}
if(readSize!=sizeof(IMAGE_TUNE_ParamSet)) {
OSA_ERROR("Invalid Param Set : Incorrect Size !!!\n");
retVal = OSA_EFAIL;
goto error_exit;
}
if(pTmpPrmSet->headerMagicNum!= IMAGE_TUNE_HEADER_MAGIC_NUM){
OSA_ERROR("Invalid Param Set : Header Magic Num Invalid !!!\n");
retVal = OSA_EFAIL;
goto error_exit;
}
checkSum = IMAGE_TUNE_CalcParamSetChecksum(pTmpPrmSet);
if(checkSum!=pTmpPrmSet->checkSum) {
OSA_ERROR("Invalid Param Set : Check Sum Failed !!!\n");
retVal = OSA_EFAIL;
goto error_exit;
}
memcpy(&gIMAGE_TUNE_ctrl.curPrm, pTmpPrmSet, sizeof(IMAGE_TUNE_ParamSet));
error_exit:
if(pTmpPrmSet != NULL)
OSA_memFree((void*)pTmpPrmSet);
#endif
return retVal;
}
int OSA_msgqFreeMsgHndl(OSA_MsgHndl *msg)
{
OSA_memFree(msg);
return OSA_SOK;
}
int OSA_mbxBroadcastMsg(OSA_MbxHndl *pMbxToList[], OSA_MbxHndl *pMbxFrom, Uint16 cmd, void *pPrm, Uint16 flags)
{
OSA_MsgHndl *pSentMsgList[OSA_MBX_BROADCAST_MAX];
Bool ackList[OSA_MBX_BROADCAST_MAX];
OSA_MsgHndl *pRcvMsg;
Bool waitAck, unknownAck;
Uint32 i, numMsg;
int retVal=OSA_SOK, ackRetVal = OSA_SOK;
OSA_MsgqHndl *ackMbx;
OSA_assert(pMbxToList!=NULL);
if(pMbxFrom==NULL) {
if(flags & OSA_MBX_WAIT_ACK) {
// if from mail box is NULL, then cannot wait for ACK
OSA_assert(0);
}
ackMbx = NULL;
} else {
ackMbx = &pMbxFrom->ackMbx;
}
// count number of mailboxes to boadcast to
numMsg=0;
while(pMbxToList[numMsg]!=NULL) {
numMsg++;
if(numMsg>=OSA_MBX_BROADCAST_MAX) {
// cannot broadcast to more than OSA_MBX_BROADCAST_MAX mailboxes
OSA_assert(0);
}
}
if(numMsg == 0) {
// no mailboxes in 'to' mailbox list
return OSA_SOK;
}
// Cannot broadcast with malloc'ed prm and not wait for ACK
if(flags & OSA_MBX_FREE_PRM) {
if( !(flags & OSA_MBX_WAIT_ACK) && numMsg > 1) {
OSA_assert(0);
}
}
// reset sent MSG list and ACK list
for(i=0; i<OSA_MBX_BROADCAST_MAX; i++) {
ackList[i] = FALSE;
pSentMsgList[i] = NULL;
}
// send MSG to all mailboxes
for(i=0; i<numMsg; i++) {
retVal = OSA_msgqSendMsg(&pMbxToList[i]->rcvMbx, ackMbx, cmd, pPrm, flags, &pSentMsgList[i]);
OSA_assertSuccess(retVal);
}
if((flags & OSA_MBX_WAIT_ACK) && ackMbx!=NULL ) {
// wait for ACKs
do {
// wait ACK
retVal = OSA_msgqRecvMsg(ackMbx, &pRcvMsg, OSA_TIMEOUT_FOREVER);
OSA_assertSuccess(retVal);
unknownAck=TRUE;
// mark ACK as received for sent MSG
for(i=0; i<numMsg; i++) {
if(pRcvMsg == pSentMsgList[i] ) {
ackList[i]=TRUE;
unknownAck=FALSE;
if(ackRetVal==OSA_SOK) {
ackRetVal = OSA_msgGetAckStatus(pRcvMsg);
}
break;
}
}
// check if all ACKs received
waitAck = FALSE;
for(i=0; i<numMsg; i++) {
if(ackList[i]==FALSE ) {
waitAck = TRUE;
break;
}
}
if(unknownAck) {
// ACK received is for some old message, hence free MSG and prm
OSA_mbxFreeMsg(pRcvMsg);
} else {
// only free MSG now, free prm after all ACKs are received
OSA_assertSuccess( OSA_msgqFreeMsgHndl(pRcvMsg) );
}
} while(waitAck);
if(flags & OSA_MBX_FREE_PRM) {
if(pPrm!=NULL) {
OSA_memFree(pPrm);
}
}
retVal = ackRetVal;
}
return retVal;
}
int AVSERVER_bufFree()
{
int i, k, status=OSA_SOK;
VIDEO_EncodeStream *pEncodeStream;
VIDEO_CaptureStream *pCaptureStream;
for(i=0; i<gAVSERVER_config.numCaptureStream; i++) {
pCaptureStream = &gVIDEO_ctrl.captureStream[i];
if( gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
&& pCaptureStream->captureNextTsk == VIDEO_TSK_LDC
) {
} else {
for(k=0; k<pCaptureStream->bufLdcInCreatePrm.numBuf; k++)
OSA_cmemFree(pCaptureStream->bufLdcInCreatePrm.bufVirtAddr[k]);
}
if( gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
&& pCaptureStream->captureNextTsk == VIDEO_TSK_VNF
) {
} else {
for(k=0; k<pCaptureStream->bufVnfInCreatePrm.numBuf; k++)
OSA_cmemFree(pCaptureStream->bufVnfInCreatePrm.bufVirtAddr[k]);
}
if( gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
&& pCaptureStream->captureNextTsk == VIDEO_TSK_ENCODE
) {
} else {
for(k=0; k<pCaptureStream->bufEncodeInCreatePrm.numBuf; k++)
OSA_cmemFree(pCaptureStream->bufEncodeInCreatePrm.bufVirtAddr[k]);
}
if(pCaptureStream->bufLdcInCreatePrm.numBuf)
OSA_bufDelete(&pCaptureStream->bufLdcIn);
if(pCaptureStream->bufVnfInCreatePrm.numBuf)
OSA_bufDelete(&pCaptureStream->bufVnfIn);
if(pCaptureStream->bufResizeInCreatePrm.numBuf)
OSA_bufDelete(&pCaptureStream->bufResizeIn);
if(pCaptureStream->bufEncodeInCreatePrm.numBuf)
OSA_bufDelete(&pCaptureStream->bufEncodeIn);
}
for(k=0; k<gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.numBuf; k++)
OSA_cmemFree(gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.bufVirtAddr[k]);
if(gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm.numBuf)
OSA_bufDelete(&gVIDEO_ctrl.faceDetectStream.bufFdIn);
if(gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm.numBuf)
OSA_bufDelete(&gVIDEO_ctrl.displayStream.bufDisplayIn);
for(i=0; i<gAVSERVER_config.numEncodeStream; i++) {
pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
for(k=0; k<pEncodeStream->bufEncryptInCreatePrm.numBuf; k++)
OSA_cmemFree(pEncodeStream->bufEncryptInCreatePrm.bufVirtAddr[k]);
for(k=0; k<pEncodeStream->bufStreamInCreatePrm.numBuf; k++)
OSA_cmemFree(pEncodeStream->bufStreamInCreatePrm.bufVirtAddr[k]);
if(pEncodeStream->bufEncryptInCreatePrm.numBuf)
OSA_bufDelete(&pEncodeStream->bufEncryptIn);
if(pEncodeStream->bufStreamInCreatePrm.numBuf)
OSA_bufDelete(&pEncodeStream->bufStreamIn);
}
for(k=0; k<gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.numBuf; k++)
{
if( gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.bufVirtAddr[k])
{
OSA_memFree(gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.bufVirtAddr[k]);
}
}
if( gVIDEO_ctrl.motionStream.bufMotionInCreatePrm.numBuf )
OSA_bufDelete(&(gVIDEO_ctrl.motionStream.bufMotionIn));
return status;
}
