static
Int32 IpcFramesInLink_freeQueuedInputBufs(IpcFramesInLink_Obj * pObj)
{
    SystemIpcFrames_ListElem *pListElem;
    Int32 status;
    UInt32 freeCount;

    freeCount = 0;
    while (1)
    {
        pListElem = ListMP_getHead(pObj->listMPOutHndl);
        if (pListElem == NULL)
            break;

        UTILS_assert(SYSTEM_IPC_FRAMES_GET_BUFSTATE(pListElem->bufState)
                     == IPC_FRAMEBUF_STATE_OUTQUE);
        SYSTEM_IPC_FRAMES_SET_BUFOWNERPROCID(pListElem->bufState);
        SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
                                     IPC_FRAMEBUF_STATE_INQUE);
        status = ListMP_putTail(pObj->listMPInHndl, (ListMP_Elem *) pListElem);
        UTILS_assert(status == ListMP_S_SUCCESS);
        pObj->stats.droppedCount++;
        freeCount++;
    }

    if (freeCount)
    {
        if(pObj->createArgs.baseCreateParams.notifyPrevLink)
        {
        //	Vps_printf("271:System_ipcSendNotify,id=%d\n",pObj->createArgs.baseCreateParams.inQueParams.prevLinkId);

            System_ipcSendNotify(pObj->createArgs.baseCreateParams.inQueParams.
                                 prevLinkId);
        }
    }

    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
Int32 IpcFramesInLink_putEmptyFrames(Utils_TskHndl * pTsk, UInt16 queId,
                                    FVID2_FrameList * pFrameBufList)
{
    IpcFramesInLink_Obj *pObj = (IpcFramesInLink_Obj *) pTsk->appData;
    UInt32 bufId;
    FVID2_Frame *pFrameBuf;
    Int32 status;
    SystemIpcFrames_ListElem *pListElem = NULL;
    UInt32 curTime;
    System_FrameInfo *frmInfo;

#ifdef SYSTEM_DEBUG_IPC_RT
    Vps_printf(" %d: IPC_FRAMES_IN   : Releasing %d framebufs !!!\n",
               Utils_getCurTimeInMsec(), pFrameBufList->numFrames);
#endif

    if ((pFrameBufList->numFrames)
         &&
         (IPC_FRAMES_IN_LINK_STATE_ACTIVE == pObj->state))
    {
        UTILS_assert(pFrameBufList->numFrames <= FVID2_MAX_FVID_FRAME_PTR);
        curTime = Utils_getCurTimeInMsec();
        pObj->stats.freeCount += pFrameBufList->numFrames;
        for (bufId = 0; bufId < pFrameBufList->numFrames; bufId++)
        {
            pFrameBuf = pFrameBufList->frames[bufId];
            frmInfo   = pFrameBuf->appData;
            UTILS_assert(frmInfo != NULL);

            pListElem = (SystemIpcFrames_ListElem *) frmInfo->pOrgListMPElem;
            UTILS_assert(pListElem->frameBuf.phyAddr[0][0]  ==
                         pFrameBuf->addr[0][0]);
            UTILS_assert(UTILS_ARRAYISVALIDENTRY(pFrameBuf,pObj->freeFrameMem));
            UTILS_assert(SYSTEM_IPC_FRAMES_GET_BUFSTATE(pListElem->bufState)
                          == IPC_FRAMEBUF_STATE_DEQUEUED);
            status = Utils_quePut(&pObj->freeFrameQue,pFrameBuf,BIOS_NO_WAIT);
            UTILS_assert(status == FVID2_SOK);
            if (curTime > pListElem->frameBuf.reserved[0])
            {
                pObj->stats.totalRoundTrip += (curTime - pListElem->frameBuf.reserved[0]);
            }
            SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
                                         IPC_FRAMEBUF_STATE_INQUE);
            status =
                ListMP_putTail(pObj->listMPInHndl, (ListMP_Elem *) pListElem);
            UTILS_assert(status == ListMP_S_SUCCESS);
        }

        if (pObj->createArgs.baseCreateParams.notifyPrevLink)
        {
//    		Vps_printf("593:System_ipcSendNotify,id=%d\n",pObj->createArgs.baseCreateParams.inQueParams.prevLinkId);

            System_ipcSendNotify(pObj->createArgs.baseCreateParams.inQueParams.
                                 prevLinkId);
        }
    }
    if (IPC_FRAMES_IN_LINK_STATE_INACTIVE == pObj->state)
    {
        Vps_printf(" %d: IPC_FRAMES_IN:Warning! Free Frames invoked after link delete\n",
                     Utils_getCurTimeInMsec());
    }
    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}
Beispiel #3
0
Int32 IpcOutM3Link_processFrames(IpcOutM3Link_Obj * pObj)
{
    System_LinkInQueParams *pInQueParams;
    FVID2_FrameList frameList;
    FVID2_Frame *pFrame;
    SystemIpcM3_ListElem *pListElem;
    Int32 status;
    Int32 frameId;
    IpcOutM3Link_ChObj *pChObj;
	
    pInQueParams = &pObj->createArgs.inQueParams;

    System_getLinksFullFrames(pInQueParams->prevLinkId,
                              pInQueParams->prevLinkQueId, &frameList);

    pObj->freeFrameList.numFrames = 0;

    if (frameList.numFrames)
    {
#ifdef SYSTEM_DEBUG_IPC_RT
        Vps_printf(" %d: IPC_OUT_M3   : Received %d frames !!!\n",
                   Utils_getCurTimeInMsec(), frameList.numFrames);
#endif

        pObj->totalFrameCount += frameList.numFrames;
        for (frameId = 0; frameId < frameList.numFrames; frameId++)
        {
            Bool          doFrameDrop;
            pFrame = frameList.frames[frameId];
            pChObj = &pObj->chObj[pFrame->channelNum];
            pChObj->inFrameRecvCount++;
            doFrameDrop = Utils_doSkipFrame(&(pChObj->frameSkipCtx));
            
            /* frame skipped due to user setting */
            if(doFrameDrop)
            {
                pChObj->inFrameUserSkipCount++;
                pObj->freeFrameList.frames[pObj->freeFrameList.numFrames] =
                    pFrame;
                pObj->freeFrameList.numFrames++;
                UTILS_assert(pObj->freeFrameList.numFrames <=
                             FVID2_MAX_FVID_FRAME_PTR);
                continue;;
            }

            status =
                Utils_queGet(&pObj->listElemQue, (Ptr *) & pListElem, 1,
                             BIOS_NO_WAIT);
            if (status != FVID2_SOK)
            {
                /* normally this condition should not happen, if it happens
                 * return the frame back to its generator */
#if 0
                Vps_printf(" IPC_OUT: Dropping frame\n");
#endif

                pObj->freeFrameList.frames[pObj->freeFrameList.numFrames] =
                    pFrame;
                pObj->freeFrameList.numFrames++;
                UTILS_assert(pObj->freeFrameList.numFrames <=
                             FVID2_MAX_FVID_FRAME_PTR);
                pChObj->inFrameUserSkipCount++;
                continue;
            }

            pListElem->pFrame = pFrame;

            /* no need to do cache ops since this is inter-M3 list */
            status = ListMP_putTail(pObj->listMPOutHndl, &pListElem->listElem);
            UTILS_assert(status == ListMP_S_SUCCESS);
            pChObj->inFrameProcessCount++;
        }

        if (pObj->freeFrameList.numFrames)
        {
            System_putLinksEmptyFrames(pInQueParams->prevLinkId,
                                       pInQueParams->prevLinkQueId,
                                       &pObj->freeFrameList);
        }

        if (pObj->createArgs.notifyNextLink)
        {
            UTILS_assert(pObj->createArgs.numOutQue == 1);
            System_ipcSendNotify(pObj->createArgs.outQueParams[0].nextLink);
        }

        if (TRUE == pObj->createArgs.noNotifyMode)
        {
            if (FALSE == pObj->prd.clkStarted)
            {
                IpcOutM3Link_startPrdObj(pObj,
                                          IPC_M3OUT_LINK_DONE_PERIOD_MS, FALSE);
            }
        }
    }

    return FVID2_SOK;
}