static Void *VdecVdis_bitsRdSendFxn(Void * prm)
{
VCODEC_BITSBUF_LIST_S emptyBufList;
UInt32 resId;
static Int printStatsInterval = 0;
OSA_semWait(&gVdecVdis_obj.thrStartSem,OSA_TIMEOUT_FOREVER);
while (FALSE == gVdecVdis_obj.thrExit)
{
OSA_waitMsecs(MCFW_IPCBITS_SENDFXN_PERIOD_MS);
for (resId = 0; resId < gVdecVdis_config.numRes; resId++)
{
VdecVdis_bitsRdGetEmptyBitBufs(&emptyBufList,resId);
VdecVdis_bitsRdReadData(&emptyBufList,resId);
VdecVdis_bitsRdSendFullBitBufs(&emptyBufList);
}
#ifdef IPCBITS_OUT_HOST_DEBUG
if ((printStatsInterval % MCFW_IPCBITS_INFO_PRINT_INTERVAL) == 0)
{
OSA_printf("MCFW_IPCBITS:%s:INFO: periodic print..",__func__);
}
#endif
printStatsInterval++;
}
return NULL;
}
static Void *VcapVencVdecVdis_ipcBitsRecvFxn(Void * prm)
{
VcapVencVdecVdis_IpcBitsCtrl *ipcBitsCtrl = (VcapVencVdecVdis_IpcBitsCtrl *) prm;
VcapVencVdecVdis_IpcBitsCtrlThrObj *thrObj = &ipcBitsCtrl->thrObj;
VcapVencVdecVdis_IpcBitsCtrlFileObj *fObj = &ipcBitsCtrl->fObj;
UInt32 printStatsInterval = OSA_getCurTimeInMsec();
UInt32 elaspedTime;
while (FALSE == thrObj->exitBitsInThread)
{
OSA_semWait(&thrObj->bitsInNotifySem,OSA_TIMEOUT_FOREVER);
VcapVencVdecVdis_ipcBitsProcessFullBufs(thrObj,
fObj,
ipcBitsCtrl->decInfo);
elaspedTime = OSA_getCurTimeInMsec() - printStatsInterval;
if (elaspedTime >= 10000)
{
#if 1
VcapVencVdecVdis_printAvgStatistics(elaspedTime, TRUE);
#endif
printStatsInterval = OSA_getCurTimeInMsec();
}
}
return NULL;
}
static Void * VdecVdis_ipcFramesSendFxn(Void * prm)
{
VdecVdis_IpcFramesCtrl *ipcFramesObj = (VdecVdis_IpcFramesCtrl *) prm;
VdecVdis_IpcFramesCtrlThrObj *thrObj = &ipcFramesObj->thrObj;
static Int printStatsInterval = 0;
VIDEO_FRAMEBUF_LIST_S bufList;
Int status;
OSA_printf("MCFW_IPCFRAMES:%s:Entered...",__func__);
OSA_semWait(&thrObj->thrStartSem,OSA_TIMEOUT_FOREVER);
OSA_printf("MCFW_IPCFRAMES:Received start signal...");
while (FALSE == thrObj->exitFramesOutThread)
{
VdecVdis_ipcFramesFillBufInfo(&bufList,
ipcFramesObj->frameObj,
OSA_ARRAYSIZE(ipcFramesObj->frameObj));
if (bufList.numFrames)
{
status = Vdis_putFullVideoFrames(&bufList);
OSA_assert(0 == status);
}
status = Vdis_getEmptyVideoFrames(&bufList,0);
OSA_assert(0 == status);
if (bufList.numFrames)
{
VdecVdis_ipcFramesPrintFullFrameListInfo(&bufList,"EmptyFrameList");
VdecVdis_ipcFramesFreeFrameBuf(&bufList,
ipcFramesObj->frameObj,
OSA_ARRAYSIZE(ipcFramesObj->frameObj));
}
printStatsInterval++;
OSA_waitMsecs(MCFW_IPCFRAMES_SENDFXN_PERIOD_MS);
}
OSA_printf("MCFW_IPCFRAMES:%s:Leaving...",__func__);
return NULL;
}
void *VcapVenc_bitsWriteMain(void *pPrm)
{
Int32 status, frameId;
VCODEC_BITSBUF_LIST_S bitsBuf;
VCODEC_BITSBUF_S *pBuf;
VcapVenc_ChInfo *pChInfo;
UInt32 latency;
FILE *fp = NULL;
UInt32 fileWriteState = FILE_WRITE_STOPPED, writeDataSize;
if(gVcapVenc_ctrl.fileWriteEnable)
{
fp = fopen(gVcapVenc_ctrl.fileWriteName, "wb");
if(fp!=NULL)
{
fileWriteState = FILE_WRITE_RUNNING;
printf(" Opened file [%s] for writing CH%d\n", gVcapVenc_ctrl.fileWriteName, gVcapVenc_ctrl.fileWriteChn);
}
else
{
printf(" ERROR: File open [%s] for writing CH%d FAILED !!!!\n", gVcapVenc_ctrl.fileWriteName, gVcapVenc_ctrl.fileWriteChn);
}
}
while(!gVcapVenc_ctrl.exitWrThr)
{
status = OSA_semWait(&gVcapVenc_ctrl.wrSem, OSA_TIMEOUT_FOREVER);
if(status!=OSA_SOK)
break;
status = Venc_getBitstreamBuffer(&bitsBuf, TIMEOUT_NO_WAIT);
if(status==ERROR_NONE && bitsBuf.numBufs)
{
for(frameId=0; frameId<bitsBuf.numBufs; frameId++)
{
pBuf = &bitsBuf.bitsBuf[frameId];
if(pBuf->chnId<VENC_CHN_MAX)
{
pChInfo = &gVcapVenc_ctrl.chInfo[pBuf->chnId];
pChInfo->totalDataSize += pBuf->filledBufSize;
pChInfo->numFrames++;
if(pBuf->frameType==VCODEC_FRAME_TYPE_I_FRAME)
{
pChInfo->numKeyFrames++;
}
latency = pBuf->encodeTimestamp - pBuf->timestamp;
if(latency > pChInfo->maxLatency)
pChInfo->maxLatency = latency;
if(latency < pChInfo->minLatency)
pChInfo->minLatency = latency;
if(pBuf->frameWidth > pChInfo->maxWidth)
pChInfo->maxWidth = pBuf->frameWidth;
if(pBuf->frameWidth < pChInfo->minWidth)
pChInfo->minWidth = pBuf->frameWidth;
if(pBuf->frameHeight > pChInfo->maxHeight)
pChInfo->maxHeight = pBuf->frameHeight;
if(pBuf->frameHeight < pChInfo->minHeight)
pChInfo->minHeight = pBuf->frameHeight;
}
if(gVcapVenc_ctrl.fileWriteEnable)
{
if(pBuf->chnId== gVcapVenc_ctrl.fileWriteChn && fileWriteState == FILE_WRITE_RUNNING)
{
writeDataSize = fwrite(pBuf->bufVirtAddr, 1, pBuf->filledBufSize, fp);
if(writeDataSize!=pBuf->filledBufSize)
{
fileWriteState = FILE_WRITE_STOPPED;
fclose(fp);
printf(" Closing file [%s] for CH%d\n", gVcapVenc_ctrl.fileWriteName, gVcapVenc_ctrl.fileWriteChn);
}
}
}
}
Venc_releaseBitstreamBuffer(&bitsBuf);
}
}
gVcapVenc_ctrl.isWrThrStopDone = TRUE;
if(gVcapVenc_ctrl.fileWriteEnable)
{
if(fileWriteState==FILE_WRITE_RUNNING)
{
fclose(fp);
printf(" Closing file [%s] for CH%d\n", gVcapVenc_ctrl.fileWriteName, gVcapVenc_ctrl.fileWriteChn);
}
}
return NULL;
}
void *SD_Demo_bitsWriteMain(void *pPrm)
{
Int32 status;
Int32 frameId;
Bitstream_BufList bitsBuf;
Bitstream_Buf *pBuf;
SD_Demo_ChInfo *pChInfo;
UInt32 latency;
FILE *fp = NULL;
UInt32 fileWriteState = FILE_WRITE_STOPPED;
UInt32 writeDataSize;
if(gSD_Demo_Ipc_Ctrl.fileWriteEnable)
{
fp = fopen(gSD_Demo_Ipc_Ctrl.fileWriteName, "wb");
if(fp!=NULL)
{
fileWriteState = FILE_WRITE_RUNNING;
printf(" Opened file [%s] for writing CH%d\n", gSD_Demo_Ipc_Ctrl.fileWriteName, gSD_Demo_Ipc_Ctrl.fileWriteChn);
}
else
{
printf(" ERROR: File open [%s] for writing CH%d FAILED !!!!\n", gSD_Demo_Ipc_Ctrl.fileWriteName, gSD_Demo_Ipc_Ctrl.fileWriteChn);
}
}
while(!gSD_Demo_Ipc_Ctrl.exitWrThr)
{
status = OSA_semWait(&gSD_Demo_Ipc_Ctrl.wrSem, OSA_TIMEOUT_FOREVER);
if(status!=OSA_SOK)
break;
/* Get buffer list from the IPC Link*/
IpcBitsInLink_getFullVideoBitStreamBufs(gSD_Demo_ctrl.ipcBitsInHLOSId[0],
&bitsBuf);
if(status== 0 && bitsBuf.numBufs)
{
for(frameId=0; frameId<bitsBuf.numBufs; frameId++)
{
pBuf = bitsBuf.bufs[frameId];
if(pBuf->channelNum<gSD_Demo_ctrl.numCapChannels)
{
pChInfo = &gSD_Demo_Ipc_Ctrl.chInfo[pBuf->channelNum];
pChInfo->totalDataSize += pBuf->fillLength;
pChInfo->numFrames++;
latency = pBuf->encodeTimeStamp - pBuf->timeStamp;
if(latency > pChInfo->maxLatency)
pChInfo->maxLatency = latency;
if(latency < pChInfo->minLatency)
pChInfo->minLatency = latency;
if(pBuf->frameWidth > pChInfo->maxWidth)
pChInfo->maxWidth = pBuf->frameWidth;
if(pBuf->frameWidth < pChInfo->minWidth)
pChInfo->minWidth = pBuf->frameWidth;
if(pBuf->frameHeight > pChInfo->maxHeight)
pChInfo->maxHeight = pBuf->frameHeight;
if(pBuf->frameHeight < pChInfo->minHeight)
pChInfo->minHeight = pBuf->frameHeight;
}
if(gSD_Demo_Ipc_Ctrl.fileWriteEnable)
{
if(pBuf->channelNum== gSD_Demo_Ipc_Ctrl.fileWriteChn && fileWriteState == FILE_WRITE_RUNNING)
{
writeDataSize = fwrite(pBuf->addr, 1, pBuf->fillLength, fp);
if(writeDataSize!=pBuf->fillLength)
{
fileWriteState = FILE_WRITE_STOPPED;
fclose(fp);
printf(" Closing file [%s] for CH%d\n", gSD_Demo_Ipc_Ctrl.fileWriteName, gSD_Demo_Ipc_Ctrl.fileWriteChn);
}
}
}
}
/* Release buffer list back to the IPC Link*/
IpcBitsInLink_putEmptyVideoBitStreamBufs(gSD_Demo_ctrl.ipcBitsInHLOSId[0],
&bitsBuf);
}
}
gSD_Demo_Ipc_Ctrl.isWrThrStopDone = TRUE;
if(gSD_Demo_Ipc_Ctrl.fileWriteEnable)
{
if(fileWriteState==FILE_WRITE_RUNNING)
{
fclose(fp);
printf(" Closing file [%s] for CH%d\n", gSD_Demo_Ipc_Ctrl.fileWriteName, gSD_Demo_Ipc_Ctrl.fileWriteChn);
}
}
return NULL;
}