/* ========================================================================== */
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_queCreate(OSA_QueHndl *hndl, Uint32 maxLen)
{
pthread_mutexattr_t mutex_attr;
pthread_condattr_t cond_attr;
int status=OSA_SOK;
hndl->curRd = hndl->curWr = 0;
hndl->count = 0;
hndl->len = maxLen;
hndl->queue = OSA_memAlloc(sizeof(Int32)*hndl->len);
if(hndl->queue==NULL) {
OSA_ERROR("OSA_queCreate() = %d \r\n", status);
return OSA_EFAIL;
}
status |= pthread_mutexattr_init(&mutex_attr);
status |= pthread_condattr_init(&cond_attr);
status |= pthread_mutex_init(&hndl->lock, &mutex_attr);
status |= pthread_cond_init(&hndl->condRd, &cond_attr);
status |= pthread_cond_init(&hndl->condWr, &cond_attr);
if(status!=OSA_SOK)
OSA_ERROR("OSA_queCreate() = %d \r\n", status);
pthread_condattr_destroy(&cond_attr);
pthread_mutexattr_destroy(&mutex_attr);
return status;
}
status_t thread_create(thread_t *pthd, Fxn fxn, thread_attrs_t * attrs, ...)
{
int i;
va_list va;
status_t status = OSA_SOK;
struct __thread_t * thd = NULL;
thread_check_arguments2(pthd, fxn);
(*pthd) = INVALID_HANDLE;
status = OSA_memAlloc(sizeof(struct __thread_t), &thd);
if (OSA_ISERROR(status) || thd == NULL) {
return status;
}
thd->pri = attrs->priority;
/*
* TODO: Bug here, the attrs variable may be exist at stack,
* the thd_hdl->name pointer may be invalid soon.
*/
thd->name = attrs->name;
thd->env = attrs->environ;
thd->fxn = fxn;
thd->thd_status = -1;
thd->exit_status = -1;
/* Copy up to 'THREAD_MAX_ARGS' arguments from task */
va_start(va, attrs);
for (i = 0; i < OSA_ARRAYSIZE(thd->args); i++) {
thd->args[i] = va_arg(va, Arg);
}
va_end(va);
/* Create a realtime detached thread */
pthread_attr_init(&thd->pattrs);
pthread_attr_setdetachstate(&thd->pattrs, PTHREAD_CREATE_DETACHED);
thd->thd_status = pthread_create(&thd->thd_id, &thd->pattrs,
(void * (*)(void *))__thread_run_stub, (void *)thd);
if (thd->thd_status != 0) {
thread_delete((thread_t *)&thd);
}
(*pthd) = (thread_t)thd;
return status;
}
OSA_MsgHndl *OSA_msgqAllocMsgHndl(OSA_MsgqHndl *to, OSA_MsgqHndl *from, Uint16 cmd, void *prm, Uint16 msgFlags)
{
OSA_MsgHndl *msg = OSA_memAlloc(sizeof(OSA_MsgHndl));
if (msg != NULL)
{
msg->pTo = to;
msg->pFrom = from;
msg->pPrm = prm;
msg->status = OSA_SOK;
msg->cmd = cmd;
msg->flags = msgFlags;
}
return msg;
}
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;
}
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 AVSERVER_bufAlloc()
{
int status=OSA_SOK;
OSA_BufHndl *pBufHndl;
OSA_BufInfo *pBufInfo;
OSA_BufCreate *pBufCreatePrm;
int bufId, i, k;
VIDEO_EncodeStream *pEncodeStream;
VIDEO_CaptureStream *pCaptureStream;
Uint32 maxbufSize = 0;
Uint32 bufSize;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Allocating buffers ...\n");
#endif
for(i=0; i<gAVSERVER_config.numCaptureStream; i++) {
pCaptureStream = &gVIDEO_ctrl.captureStream[i];
bufSize = pCaptureStream->captureOutOffsetH * pCaptureStream->captureOutOffsetV;
if(gAVSERVER_config.captureYuvFormat == DRV_DATA_FORMAT_YUV420)
bufSize += bufSize/2;
else
bufSize += bufSize;
bufSize += VIDEO_BUF_HEADER_SIZE;
pBufHndl = &pCaptureStream->bufLdcIn;
pBufCreatePrm = &pCaptureStream->bufLdcInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Allocating LDC buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
#endif
if( gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
&& pCaptureStream->captureNextTsk == VIDEO_TSK_LDC
) {
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
}
} else {
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
pBufHndl = &pCaptureStream->bufVnfIn;
pBufCreatePrm = &pCaptureStream->bufVnfInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Allocating VNF buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
#endif
if( gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
&& pCaptureStream->captureNextTsk == VIDEO_TSK_VNF
) {
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
}
} else {
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
pBufHndl = &pCaptureStream->bufEncodeIn;
pBufCreatePrm = &pCaptureStream->bufEncodeInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Allocating Encode IN buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
#endif
if( gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN
&& pCaptureStream->captureNextTsk == VIDEO_TSK_ENCODE
) {
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufInfo = DRV_ipipeGetRszBufInfo(i, k);
pBufCreatePrm->bufVirtAddr[k] = pBufInfo->virtAddr;
pBufCreatePrm->bufPhysAddr[k] = pBufInfo->physAddr;
}
} else {
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
pBufHndl = &pCaptureStream->bufResizeIn;
pBufCreatePrm = &pCaptureStream->bufResizeInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Assigning Resize IN buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
#endif
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = pCaptureStream->bufEncodeInCreatePrm.bufVirtAddr[k];
pBufCreatePrm->bufPhysAddr[k] = pCaptureStream->bufEncodeInCreatePrm.bufPhysAddr[k];
}
if(pBufCreatePrm->numBuf) {
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
}
if(pCaptureStream->bufResizeIn.numBuf) {
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Getting Encode IN buffers\n", i);
#endif
while( OSA_bufGetEmpty(&pCaptureStream->bufEncodeIn, &bufId, OSA_TIMEOUT_NONE) == OSA_SOK) {
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Encode IN buffers %d\n", i, bufId);
#endif
}
}
if(gAVSERVER_config.captureRawInMode==AVSERVER_CAPTURE_RAW_IN_MODE_ISIF_IN)
{
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Getting Capture OUT buffers\n", i);
#endif
while( AVSERVER_bufGetEmpty( VIDEO_TSK_CAPTURE, i, &bufId, OSA_TIMEOUT_NONE) != NULL) {
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Capture OUT buffers %d\n", i, bufId);
#endif
}
}
}
bufSize = OSA_align(gVIDEO_ctrl.faceDetectStream.fdOffsetH, 32)*gVIDEO_ctrl.faceDetectStream.fdHeight*2;
bufSize += VIDEO_BUF_HEADER_SIZE;
pBufHndl = &gVIDEO_ctrl.faceDetectStream.bufFdIn;
pBufCreatePrm = &gVIDEO_ctrl.faceDetectStream.bufFdInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Allocating FD buffers: %d of size %d bytes\n", pBufCreatePrm->numBuf, bufSize);
#endif
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
pBufHndl = &gVIDEO_ctrl.displayStream.bufDisplayIn;
pBufCreatePrm = &gVIDEO_ctrl.displayStream.bufDisplayInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Assigning Display buffers: %d of size %d bytes\n", pBufCreatePrm->numBuf, bufSize);
#endif
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = gVIDEO_ctrl.displayStream.displayInfo.virtAddr[k];
pBufCreatePrm->bufPhysAddr[k] = gVIDEO_ctrl.displayStream.displayInfo.physAddr[k];
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
for(i=0; i<gAVSERVER_config.numEncodeStream; i++) {
pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
bufSize = gAVSERVER_config.encodeConfig[i].cropWidth*gAVSERVER_config.encodeConfig[i].cropHeight;
switch(gAVSERVER_config.encodeConfig[i].codecType) {
default:
case ALG_VID_CODEC_MJPEG:
bufSize /= 1;
break;
case ALG_VID_CODEC_H264:
case ALG_VID_CODEC_MPEG4:
bufSize /= 2;
break;
}
bufSize += VIDEO_BUF_HEADER_SIZE;
bufSize = OSA_align(bufSize, KB);
pBufHndl = &pEncodeStream->bufEncryptIn;
pBufCreatePrm = &pEncodeStream->bufEncryptInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Allocating Encrypt buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
#endif
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
pBufHndl = &pEncodeStream->bufStreamIn;
pBufCreatePrm = &pEncodeStream->bufStreamInCreatePrm;
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Stream %d: Allocating Stream buffers: %d of size %d bytes\n", i, pBufCreatePrm->numBuf, bufSize);
#endif
for(k=0; k<pBufCreatePrm->numBuf; k++) {
pBufCreatePrm->bufVirtAddr[k] = OSA_cmemAlloc(bufSize, 32);
pBufCreatePrm->bufPhysAddr[k] = OSA_cmemGetPhysAddr(pBufCreatePrm->bufVirtAddr[k]);
if(pBufCreatePrm->bufVirtAddr[k]==NULL||pBufCreatePrm->bufPhysAddr[k]==NULL) {
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
}
maxbufSize = 32;
for(i=0; i<gAVSERVER_config.numEncodeStream; i++)
{
pEncodeStream = &gVIDEO_ctrl.encodeStream[i];
bufSize = ALG_vidEncGetMVdataSize( pEncodeStream->algEncHndl );
if( maxbufSize < bufSize )
{
maxbufSize = bufSize;
}
}
gVIDEO_ctrl.motionStream.maxbufsize = maxbufSize;
pBufHndl = &gVIDEO_ctrl.motionStream.bufMotionIn;
pBufCreatePrm = &gVIDEO_ctrl.motionStream.bufMotionInCreatePrm;
for(k=0; k<pBufCreatePrm->numBuf; k++)
{
pBufCreatePrm->bufVirtAddr[k] = OSA_memAlloc(maxbufSize);
pBufCreatePrm->bufPhysAddr[k] = 0;
if(pBufCreatePrm->bufVirtAddr[k]==NULL)
{
OSA_ERROR("OSA_cmemAlloc()\n");
return OSA_EFAIL;
}
}
if(pBufCreatePrm->numBuf)
status |= OSA_bufCreate(pBufHndl, pBufCreatePrm);
if(status!=OSA_SOK)
OSA_ERROR("\n");
#ifdef AVSERVER_DEBUG_MAIN_THR
OSA_printf(" AVSERVER MAIN: Allocating buffers ...DONE\n");
#endif
return status;
}
