dm8148 videoM3 link源码解析

例子：从A8送一帧jpeg图片到videoM3解码，然后在将解码的数据传递到A8, 这个流程涉及的link源码如下：

dm8148 link之间数据传递

1）在A8上调用IpcBitsOutLink_getEmptyVideoBitStreamBufs从IpcBitsOutLink获取buff；然后调用IpcBitsOutLink_putFullVideoBitStreamBufs将数据送入到IpcBitsOutLink；

1.1)IpcBitsOutLink
A8调用IpcBitsOutLink将压缩数据（jpeg，mpeg4，h264）送入到videoM3；首先在/src_linux\links\system的system_common.c中调用IpcBitsOutLink_init函数；
//system_init函数在app初始化时调用；
Int32 System_init()
{
    Int32         status;

    #ifdef SYSTEM_DEBUG
    OSA_printf ( " %u: SYSTEM: System Common Init in progress !!!\n", OSA_getCurTimeInMsec());
    #endif

    memset(&gSystem_objCommon, 0, sizeof(gSystem_objCommon));

    System_ipcInit();

    IpcBitsInLink_init();
    IpcBitsOutLink_init();
    IpcFramesInLink_init();
    IpcFramesOutLink_init();

    ...........
    status = OSA_mbxCreate(&gSystem_objCommon.mbx);
    UTILS_assert(  status==OSA_SOK);

    SystemLink_init();

    #ifdef SYSTEM_DEBUG
    OSA_printf ( " %u: SYSTEM: System Common Init Done !!!\n", OSA_getCurTimeInMsec());
    #endif

    return status;
}

1.2)IpcBitsOutLink_init函数
Int32 IpcBitsOutLink_init()
{
    Int32 status;
    System_LinkObj linkObj;
    UInt32 ipcBitsOutId;
    IpcBitsOutLink_Obj *pObj;
    char tskName[32];
    UInt32 procId = System_getSelfProcId();

    OSA_COMPILETIME_ASSERT(offsetof(SystemIpcBits_ListElem, bitBuf) == 0);
    OSA_COMPILETIME_ASSERT(offsetof(Bitstream_Buf, reserved) == 0);
    OSA_COMPILETIME_ASSERT(sizeof(((Bitstream_Buf *) 0)->reserved) ==
                           sizeof(ListMP_Elem));
    for (ipcBitsOutId = 0; ipcBitsOutId < IPC_BITS_OUT_LINK_OBJ_MAX;
         ipcBitsOutId++)
    {
        pObj = &gIpcBitsOutLink_obj[ipcBitsOutId];

        memset(pObj, 0, sizeof(*pObj));

        pObj->tskId =
            SYSTEM_MAKE_LINK_ID(procId,
                                SYSTEM_LINK_ID_IPC_BITS_OUT_0) + ipcBitsOutId;

        linkObj.pTsk = &pObj->tsk;
        linkObj.getLinkInfo = IpcBitsOutLink_getLinkInfo;

        System_registerLink(pObj->tskId, &linkObj);

        OSA_SNPRINTF(tskName, "IPC_BITS_OUT%d", ipcBitsOutId);
        
	//注册通知
        System_ipcRegisterNotifyCb(pObj->tskId, IpcBitsOutLink_notifyCb);
	
	//初始化ListMP
        IpcBitsOutLink_initListMP(pObj);

        status = OSA_tskCreate(&pObj->tsk,
                               IpcBitsOutLink_tskMain,
                               IPC_LINK_TSK_PRI,
                               IPC_LINK_TSK_STACK_SIZE, 0, pObj);
        OSA_assert(status == OSA_SOK);
    }

    return status;
}


1.3）IpcBitsOutLink_tskMain函数
Int IpcBitsOutLink_tskMain(struct OSA_TskHndl * pTsk, OSA_MsgHndl * pMsg,
                           Uint32 curState)
{
    UInt32 cmd = OSA_msgGetCmd(pMsg);
    Bool ackMsg, done;
    Int32 status = IPC_BITSOUT_LINK_S_SUCCESS;
    //appData中保存的是和link相关的参数
    IpcBitsOutLink_Obj *pObj = (IpcBitsOutLink_Obj *) pTsk->appData;
    
    //SYSTEM_CMD_CREATE为System_linkCreate函数的命令号，如果cmd!=SYSTEM_CMD_CREATE,主函数退出？？？
    if (cmd != SYSTEM_CMD_CREATE)
    {
        OSA_tskAckOrFreeMsg(pMsg, OSA_EFAIL);
        return status;
    }

    status = IpcBitsOutLink_create(pObj, OSA_msgGetPrm(pMsg));

    OSA_tskAckOrFreeMsg(pMsg, status);

    if (status != OSA_SOK)
        return status;

    done = FALSE;
    ackMsg = FALSE;

    while (!done)
    {
        status = OSA_tskWaitMsg(pTsk, &pMsg);
        if (status != OSA_SOK)
            break;

        cmd = OSA_msgGetCmd(pMsg);

        switch (cmd)
        {
            case SYSTEM_CMD_DELETE:
                done = TRUE;
                ackMsg = TRUE;
                break;

            case SYSTEM_IPC_CMD_RELEASE_FRAMES:
                OSA_tskAckOrFreeMsg(pMsg, status);

#ifdef SYSTEM_DEBUG_IPC_RT
                OSA_printf(" %d: IPC_BITS_OUT   : Received Notify !!!\n",
                           OSA_getCurTimeInMsec());
#endif

                IpcBitsOutLink_releaseBitBufs(pObj);
                break;

            case SYSTEM_CMD_START:
		//link start
                IpcBitsOutLink_start(pObj);
                OSA_tskAckOrFreeMsg(pMsg, status);
                break;

            case SYSTEM_CMD_STOP:
		//link stop
                IpcBitsOutLink_stop(pObj);
                OSA_tskAckOrFreeMsg(pMsg, status);
                break;

            default:
                OSA_tskAckOrFreeMsg(pMsg, status);
                break;
        }
    }

    IpcBitsOutLink_delete(pObj);

#ifdef SYSTEM_DEBUG_IPC_BITS_OUT
    OSA_printf(" %d: IPC_BITS_OUT   : Delete Done !!!\n",
               OSA_getCurTimeInMsec());
#endif

    if (ackMsg && pMsg != NULL)
        OSA_tskAckOrFreeMsg(pMsg, status);

    return IPC_BITSOUT_LINK_S_SUCCESS;
}

1.4）IpcBitsOutLink_create函数
Int32 IpcBitsOutLink_create(IpcBitsOutLink_Obj * pObj,
                            IpcBitsOutLinkHLOS_CreateParams * pPrm)
{
    Int32 status;
    UInt32 i;

#ifdef SYSTEM_DEBUG_IPC
    OSA_printf(" %d: IPC_BITS_OUT   : Create in progress !!!\n",
               OSA_getCurTimeInMsec());
#endif

    memcpy(&pObj->createArgs, pPrm, sizeof(pObj->createArgs));

    for (i=0; i<IPC_LINK_BITS_OUT_MAX_NUM_ALLOC_POOLS; i++)
    {
        OSA_assert(i < IPC_BITS_OUT_MAX_NUM_ALLOC_POOLS);
        if(pObj->createArgs.numBufPerCh[i] == 0)
            pObj->createArgs.numBufPerCh[i] =
                  IPC_BITS_OUT_LINK_MAX_OUT_FRAMES_PER_CH;

        if(pObj->createArgs.numBufPerCh[i] >
                 IPC_BITS_OUT_LINK_MAX_OUT_FRAMES_PER_CH)
        {
            OSA_printf("\n IPCBITSOUTLINK: WARNING: User is asking for %d buffers per CH. But max allowed is %d. \n"
                " Over riding user requested with max allowed \n\n",
                pObj->createArgs.numBufPerCh[i],
                IPC_BITS_OUT_LINK_MAX_OUT_FRAMES_PER_CH
                );

            pObj->createArgs.numBufPerCh[i] =
                  IPC_BITS_OUT_LINK_MAX_OUT_FRAMES_PER_CH;

        }
    }

    //listMP 队列清空
    status = System_ipcListMPReset(pObj->listMPOutHndl, pObj->listMPInHndl);
    OSA_assert(status == OSA_SOK);

    //分配link的内存
    IpcBitsOutLink_createOutObj(pObj);

    IpcBitsOutLink_initStats(pObj);

    pObj->startProcessing = FALSE;

#ifdef SYSTEM_DEBUG_IPC
    OSA_printf(" %d: IPC_BITS_OUT   : Create Done !!!\n",
               OSA_getCurTimeInMsec());
#endif

    return IPC_BITSOUT_LINK_S_SUCCESS;
}

1.5）IpcBitsOutLink_createOutObj函数分配该link需要多少内存，link的内存由link自己管理，在建立link时，告诉该link 内存池的个数，每个池中的buff的个数，link自己决定分配多少内存；

static Int IpcBitsOutLink_createOutObj(IpcBitsOutLink_Obj * pObj)
{
    Int status = OSA_SOK;
    Int32 poolId, elemId, bufId;
    IHeap_Handle srBitBufHeapHandle;
    UInt32 bufSize, numBufs, totBufSize, cacheLineSize;
    const UInt32 srIndex = SYSTEM_IPC_SR_CACHED;
    Ptr   phyAddr;

    ipcbitsoutlink_populate_outbuf_pool_size_info(&pObj->createArgs,
                                                  &pObj->createArgs.inQueInfo,
                                                  &pObj->outQueInfo);
    elemId = 0;
    srBitBufHeapHandle = SharedRegion_getHeap(srIndex);
    OSA_assert(srBitBufHeapHandle != NULL);
    cacheLineSize = SharedRegion_getCacheLineSize(srIndex);
    for (poolId = 0; poolId < pObj->outQueInfo.allocPoolInfo.numPools; poolId++)
    {
        status = OSA_queCreate(&pObj->listElemQue[poolId],
                               SYSTEM_IPC_BITS_MAX_LIST_ELEM);
        OSA_assert(status == OSA_SOK);
        bufSize =
            OSA_align(pObj->outQueInfo.allocPoolInfo.bufPoolInfo[poolId].
                      bufSize, cacheLineSize);
        numBufs = pObj->outQueInfo.allocPoolInfo.bufPoolInfo[poolId].numBufs;
	
        //总共需要分配的内存大小
        totBufSize = bufSize * numBufs;
        OSA_printf ("###Bit buff of size from the SR # %d : %d\n", srIndex, totBufSize);
        pObj->bitBufPoolPtr[poolId] =
            Memory_alloc(srBitBufHeapHandle, totBufSize, cacheLineSize, NULL);
        OSA_assert(pObj->bitBufPoolPtr[poolId] != NULL);
        OSA_printf("IPC_BITSOUT:BitBuffer Alloc.PoolID:%d,Size:0x%X",
                    poolId,totBufSize);
        phyAddr = IpcBitsOutLink_MapUsrVirt2Phy(pObj->bitBufPoolPtr[poolId]);
        pObj->bitBufPoolSize[poolId] = totBufSize;
        for (bufId = 0; bufId < numBufs; bufId++)
        {
            SystemIpcBits_ListElem *listElem;

            OSA_assert(elemId < SYSTEM_IPC_BITS_MAX_LIST_ELEM);
            listElem = pObj->listElem[elemId];
            elemId++;
            SYSTEM_IPC_BITS_SET_BUFOWNERPROCID(listElem->bufState);
            SYSTEM_IPC_BITS_SET_BUFSTATE(listElem->bufState,
                                         IPC_BITBUF_STATE_FREE);
            listElem->bitBuf.addr =
                (Ptr) (((UInt32) (pObj->bitBufPoolPtr[poolId])) +
                       (bufSize * bufId));
            if (phyAddr)
            {
                listElem->bitBuf.phyAddr =
                    (UInt32) ((UInt32) (phyAddr) +  (bufSize * bufId));
            }
            listElem->bitBuf.allocPoolID = poolId;
            listElem->bitBuf.bufSize = bufSize;
            listElem->bitBuf.fillLength = 0;
            listElem->bitBuf.mvDataFilledSize = 0;
            listElem->bitBuf.startOffset = 0;
            listElem->bitBuf.bottomFieldBitBufSize = 0;
            listElem->bitBuf.doNotDisplay = FALSE;
            //获取Buf的指针
            listElem->srBufPtr = SharedRegion_getSRPtr(listElem->bitBuf.addr,
                                                       srIndex);
            OSA_assert(listElem->srBufPtr != IPC_LINK_INVALID_SRPTR);
            //将分配的buff挂在插入list队列，使用时，从队列中取empty buff，比如在A8需要将bit数据拷贝传递到IpcBitsOutLink，调用IpcBitsOutLink_getEmptyVideoBitStreamBufs

（IpcBitsOutLink_getEmptyBufs）从队列中取buff；
            status =
                OSA_quePut(&pObj->listElemQue[poolId], (Int32) listElem,
                           OSA_TIMEOUT_NONE);
            OSA_assert(status == OSA_SOK);
        }
    }
    return status;
}

1.6）A8中调用该函数将buff传递IpcBitsOutLink
Int32 IpcBitsOutLink_putFullVideoBitStreamBufs(UInt32 linkId,
                                               Bitstream_BufList *bufList)
{
    OSA_TskHndl * pTsk;
    IpcBitsOutLink_Obj * pObj;
    Int status;

    OSA_assert(bufList != NULL);
    if (!((linkId  >= SYSTEM_HOST_LINK_ID_IPC_BITS_OUT_0)
          &&
          (linkId  < (SYSTEM_HOST_LINK_ID_IPC_BITS_OUT_0 + IPC_BITS_OUT_LINK_OBJ_MAX))))
    {
        return IPC_BITSOUT_LINK_E_INVALIDLINKID;
    }
    pTsk = System_getLinkTskHndl(linkId);
    pObj = pTsk->appData;
    
    //将buff传递到下一个link
    status = IpcBitsOutLink_putFullBufs(pObj,bufList);
    return status;
}

1.7）IpcBitsOutLink_putFullBufs 将buff传递到下一个link，注意IpcBitsOutLink_listMPPut，将buff压入到输出队列，然后发送System_ipcSendNotify 发送通知，通知下一个link来取数据；
static
Int32 IpcBitsOutLink_putFullBufs(IpcBitsOutLink_Obj *pObj,
                                 Bitstream_BufList *pBufList)
{
    SystemIpcBits_ListElem *pListElem;
    Bitstream_Buf *pBitBuf;
    Bitstream_BufList freeBitBufList;
    Bool putDone = FALSE;
    Int32 bufId;
    UInt32 curTime;

    freeBitBufList.numBufs = 0;
    curTime = OSA_getCurTimeInMsec();
    for (bufId = 0; bufId < pBufList->numBufs; bufId++)
    {
        pBitBuf = pBufList->bufs[bufId];
		curTime = pBitBuf->timeStamp = Get_timeStamp(pBitBuf->channelNum); 

		pListElem = (SystemIpcBits_ListElem *)pBitBuf;
        OSA_assert(SharedRegion_getPtr(pListElem->srBufPtr) ==
                   pBitBuf->addr);
        if (0 == pBitBuf->fillLength)
        {
            /* filled length of 0 indicates application
             * did not fill any data in this buffer.
             * Free it immediately */
#ifdef SYSTEM_DEBUG_IPC_RT
                OSA_printf(" IPC_OUT: Dropping bitbuf\n");
#endif

            OSA_assert(freeBitBufList.numBufs <
                       VIDBITSTREAM_MAX_BITSTREAM_BUFS);
            freeBitBufList.bufs[freeBitBufList.numBufs] = pBitBuf;
            freeBitBufList.numBufs++;
            pObj->stats.droppedCount++;
            continue;
        }
        else
        {
            pObj->stats.recvCount++;
            OSA_assert(SYSTEM_IPC_BITS_GET_BUFSTATE(pListElem->bufState)
                       == IPC_BITBUF_STATE_FREE);
            OSA_assert(SYSTEM_IPC_BITS_GET_BUFOWNERPROCID(pListElem->bufState)
                       == System_getSelfProcId());
            pListElem->ipcPrivData = (Ptr) curTime;
            SYSTEM_IPC_BITS_SET_BUFSTATE(pListElem->bufState,
                                         IPC_BITBUF_STATE_ALLOCED);
            //压入到输出队列
            IpcBitsOutLink_listMPPut(pObj, pListElem);
            putDone = TRUE;
        }
    }
    if (freeBitBufList.numBufs)
    {
        IpcBitsOutLink_putEmptyBufs(pObj, &freeBitBufList);
    }

    if (putDone && (pObj->createArgs.baseCreateParams.notifyNextLink))
    {
        //通知下一个link，调用Notify_sendEvent函数
        System_ipcSendNotify(pObj->createArgs.baseCreateParams.outQueParams[0].
                             nextLink);
    }
    if (!putDone)
    {
        pObj->stats.numNoFullBufCount++;
        if ((pObj->stats.numNoFullBufCount % IPC_BITSOUT_STATS_WARN_INTERVAL) == 0)
        {
            #ifdef DEBUG_IPC_BITS
            OSA_printf("IPCBITSOUT:!!!WARNING.!!! NO FULL BUF AVAILABLE. OCCURENCE COUNT:[%d]",
                       pObj->stats.numNoFullBufCount);
            #endif
        }
    }
    return IPC_BITSOUT_LINK_S_SUCCESS;
}

1.8）IpcBitsOutLink_listMPPut 函数
static
Int32 IpcBitsOutLink_listMPPut(IpcBitsOutLink_Obj * pObj,
                               SystemIpcBits_ListElem * pListElem)
{
    Int32 status = IPC_BITSOUT_LINK_S_SUCCESS;

    SYSTEM_IPC_BITS_SET_BUFSTATE(pListElem->bufState, IPC_BITBUF_STATE_OUTQUE);
    //cache 多核之间数据拷贝，传递到ipcbitsIn(videoM3) link

    IpcBitsOutLink_doPrePutCacheOp(pObj, pListElem);
    status = ListMP_putTail(pObj->listMPOutHndl, (ListMP_Elem *) pListElem);
    OSA_assert(status == ListMP_S_SUCCESS);
    return IPC_BITSOUT_LINK_S_SUCCESS;
}


1.9）IpcBitsOutLink_doPrePutCacheOp 函数；
static
Int32 IpcBitsOutLink_doPrePutCacheOp(IpcBitsOutLink_Obj * pObj,
                                     SystemIpcBits_ListElem * pListElem)
{
    if (pListElem->bitBuf.fillLength)
    {
        Cache_wbInv(pListElem->bitBuf.addr,
                    pListElem->bitBuf.fillLength, Cache_Type_ALL, TRUE);
    }
    /* No cache ops done since pListElem is allocated from non-cached memory */
    UTILS_assert(SharedRegion_isCacheEnabled(SharedRegion_getId(pListElem)) ==
                 FALSE);
    return IPC_BITSOUT_LINK_S_SUCCESS;
}

ListMP_putTail 和ListMP_getHead 作用，多核之间用吗？相邻2个核之间的link公用一个ListMp队列吗？ipcBitsOutLink(A8)发送通知Notify_sendEvent告诉ipcBitsInLink(videoM3),在

ListMP队列已经存在数据；

ListMP实现了多宿主双向循环链表，即该双向循环链表为多个处理器共同拥有，可以由多个处理器共同维护，共同使用。
ListMP的实现区别于一般的双向循环链表，因此它不仅具有双向循环链表的特性外，还增添了其他的特性，比如以下几点：
1.实现了简单的多宿主协议，支持多个读写者（multi-reader、multi-writee）；
2.使用Gate作为内部保护机制，防止多个宿主处理器同时访问该链表；
ListMP的实现并未加入通知机制，如果需要的话，可以在外部封装是引入Notify机制来实现；使用ListMP机制来管理的buffers都需要从共享内存区分配，包括从堆内存分配的buffers以及动

态分配的内存。


2）videoM3 systemLink 多核之间数据传递要用到systemlink，以下是videoM3中systemLink的初始化函数；主要有IpcOutM3Link_init()函数和IpcInM3Link_init()函数；
mcfw/src_bios6/links_m3video/system ;system_m3video.c

Int32 System_init()
{
    Int32 status = FVID2_SOK;

#ifdef SYSTEM_DEBUG
    Vps_printf(" %d: SYSTEM  : System Video Init in progress !!!\n",
               Utils_getCurTimeInMsec());
#endif

#ifdef SYSTEM_DEBUG
    Vps_printf(" %d: SYSTEM  : System Video Init Done !!!\n", Utils_getCurTimeInMsec());
#endif
    IpcOutM3Link_init();
    IpcInM3Link_init();

    IpcBitsInLink_init();
    IpcBitsOutLink_init();
    IpcFramesInLink_init();
    IpcFramesOutLink_init();
    
    Utils_encdecInit();
    
    //编解码link初始化
    System_initLinks();
	
    return status;
}

3）IpcBitsInLink(mcfw_bios6)


3.1)初始化函数
Int32 IpcBitsInLink_init()
{
    Int32 status;
    System_LinkObj linkObj;
    UInt32 ipcBitsInId;
    IpcBitsInLink_Obj *pObj;
    char tskName[32];
    UInt32 procId = System_getSelfProcId();

    UTILS_COMPILETIME_ASSERT(offsetof(SystemIpcBits_ListElem, bitBuf) == 0);
    UTILS_COMPILETIME_ASSERT(offsetof(Bitstream_Buf, reserved) == 0);
    UTILS_COMPILETIME_ASSERT(sizeof(((Bitstream_Buf *) 0)->reserved) ==
                             sizeof(ListMP_Elem));

    for (ipcBitsInId = 0; ipcBitsInId < IPC_BITS_IN_LINK_OBJ_MAX; ipcBitsInId++)
    {
        pObj = &gIpcBitsInLink_obj[ipcBitsInId];

        memset(pObj, 0, sizeof(*pObj));

        pObj->tskId =
            SYSTEM_MAKE_LINK_ID(procId,
                                SYSTEM_LINK_ID_IPC_BITS_IN_0) + ipcBitsInId;

        pObj->state = IPC_BITS_IN_LINK_STATE_INACTIVE;
        linkObj.pTsk = &pObj->tsk;
        linkObj.linkGetFullFrames = NULL;
        linkObj.linkPutEmptyFrames = NULL;
        linkObj.linkGetFullBitBufs = IpcBitsInLink_getFullBitBufs;
        linkObj.linkPutEmptyBitBufs = IpcBitsInLink_putEmptyBitBufs;
        linkObj.getLinkInfo = IpcBitsInLink_getLinkInfo;

        System_registerLink(pObj->tskId, &linkObj);

        UTILS_SNPRINTF(tskName, "IPC_BITS_IN%d", ipcBitsInId);

        System_ipcRegisterNotifyCb(pObj->tskId, IpcBitsInLink_notifyCb);

        status = Utils_tskCreate(&pObj->tsk,
                                 IpcBitsInLink_tskMain,
                                 IPC_LINK_TSK_PRI,
                                 gIpcBitsInLink_tskStack[ipcBitsInId],
                                 IPC_LINK_TSK_STACK_SIZE, pObj, tskName);
        UTILS_assert(status == FVID2_SOK);
    }

    return status;
}

3.2）IpcBitsInLink_tskMain 主函数
Void IpcBitsInLink_tskMain(struct Utils_TskHndl * pTsk, Utils_MsgHndl * pMsg)
{
    UInt32 cmd = Utils_msgGetCmd(pMsg);
    Bool ackMsg, done;
    Int32 status;
    IpcBitsInLink_Obj *pObj = (IpcBitsInLink_Obj *) pTsk->appData;

    if (cmd != SYSTEM_CMD_CREATE)
    {
        Utils_tskAckOrFreeMsg(pMsg, FVID2_EFAIL);
        return;
    }

    //ListMP 和队列资源初始化
    status = IpcBitsInLink_create(pObj, Utils_msgGetPrm(pMsg));

    Utils_tskAckOrFreeMsg(pMsg, status);

    if (status != FVID2_SOK)
        return;

    done = FALSE;
    ackMsg = FALSE;

    while (!done)
    {
	//接收消息，是接收从ipcbitsOutlink(A8)
        status = Utils_tskRecvMsg(pTsk, &pMsg, BIOS_WAIT_FOREVER);
        if (status != FVID2_SOK)
            break;

        cmd = Utils_msgGetCmd(pMsg);

        switch (cmd)
        {
            case SYSTEM_CMD_DELETE:
                done = TRUE;
                ackMsg = TRUE;
                break;
            case SYSTEM_CMD_NEW_DATA:
		//从IpcInM3 Link获取消息
                Utils_tskAckOrFreeMsg(pMsg, status);

                IpcBitsInLink_processBitBufs(pObj);
                break;
            case SYSTEM_CMD_STOP:
                IpcBitsInLink_stop(pObj);
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;
            default:
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;
        }
    }

    IpcBitsInLink_delete(pObj);

#ifdef SYSTEM_DEBUG_IPC_BITS_IN
    Vps_printf(" %d: IPC_BITS_IN   : Delete Done !!!\n", Utils_getCurTimeInMsec());
#endif

    if (ackMsg && pMsg != NULL)
        Utils_tskAckOrFreeMsg(pMsg, status);

    return;
}


3.3）IpcBitsInLink_processBitBufs函数
Int32 IpcBitsInLink_processBitBufs(IpcBitsInLink_Obj * pObj)
{
    Bitstream_Buf *pBitBuf;
    SystemIpcBits_ListElem *pListElem;
    UInt32 numBitBufs;
    Int32 status;
    UInt32 curTime;

    numBitBufs = 0;
    curTime = Utils_getCurTimeInMsec();
    while (1)
    {
	//获取listElem，多核之间获取数据；
        pListElem = ListMP_getHead(pObj->listMPOutHndl);
        if (pListElem == NULL)
            break;
	
	//转化为bitbuff
        IpcBitsInLink_getBitBuf(pObj, pListElem, &pBitBuf);
        UTILS_assert(SYSTEM_IPC_BITS_GET_BUFSTATE(pListElem->bufState)
                     == IPC_BITBUF_STATE_OUTQUE);
        pBitBuf->reserved[0] = curTime;
        SYSTEM_IPC_BITS_SET_BUFOWNERPROCID(pListElem->bufState);
        SYSTEM_IPC_BITS_SET_BUFSTATE(pListElem->bufState,
                                     IPC_BITBUF_STATE_DEQUEUED);
        pObj->stats.recvCount++;
	//压入到输出队列；
        status = Utils_quePut(&pObj->outBitBufQue, pBitBuf, BIOS_NO_WAIT);
        UTILS_assert(status == FVID2_SOK);

        numBitBufs++;
    }

#ifdef SYSTEM_DEBUG_IPC_RT
    Vps_printf(" %d: IPC_BITS_IN   : Recevived %d bitbufs !!!\n",
               Utils_getCurTimeInMsec(), numBitBufs);
#endif

    //给下一个link发送消息
    if (numBitBufs && pObj->createArgs.baseCreateParams.notifyNextLink)
    {
        UTILS_assert(pObj->createArgs.baseCreateParams.numOutQue == 1);
        System_sendLinkCmd(pObj->createArgs.baseCreateParams.outQueParams[0].
                           nextLink, SYSTEM_CMD_NEW_DATA);
    }

    return IPC_BITS_IN_LINK_S_SUCCESS;
}

4）VideoM3 declink

4.1)解码link初始化函数
Int32 DecLink_init()
{
    Int32 status;
    System_LinkObj linkObj;
    DecLink_Obj *pObj;
    char name[32];
    UInt32 objId;

    for (objId = 0; objId < DEC_LINK_OBJ_MAX; objId++)
    {
        pObj = &gDecLink_obj[objId];

        memset(pObj, 0, sizeof(*pObj));
        pObj->linkId = SYSTEM_LINK_ID_VDEC_0 + objId;

        linkObj.pTsk = &pObj->tsk;
        linkObj.linkGetFullFrames = DecLink_getFullFrames;
        linkObj.linkPutEmptyFrames = DecLink_putEmptyFrames;
        linkObj.linkGetFullBitBufs = NULL;
        linkObj.linkPutEmptyBitBufs = NULL;
        linkObj.getLinkInfo = DecLink_getInfo;

        UTILS_SNPRINTF(name, "DEC%d   ", objId);

        System_registerLink(pObj->linkId, &linkObj);

        status = Utils_tskCreate(&pObj->tsk,
                                 DecLink_tskMain,
                                 DEC_LINK_TSK_PRI,
                                 gDecLink_tskStack[objId],
                                 DEC_LINK_TSK_STACK_SIZE, pObj, name);
        UTILS_assert(status == FVID2_SOK);
    }

    return status;
}


4.2）DecLink_tskMain 主函数
Void DecLink_tskMain(struct Utils_TskHndl *pTsk, Utils_MsgHndl * pMsg)
{
    UInt32 cmd = Utils_msgGetCmd(pMsg);
    Bool ackMsg, done;
    Int32 status;
    DecLink_Obj *pObj;
    UInt32 flushCmds[2];

    pObj = (DecLink_Obj *) pTsk->appData;

    if (cmd != SYSTEM_CMD_CREATE)
    {
        #ifndef DEC_LINK_SUPRESS_ERROR_AND_RESET
        DECLINK_INTERNAL_ERROR_LOG(DEC_LINK_E_INVALIDCMD,
                                   "Link create should be first cmd."
                                   "Received Cmd:%d", cmd);
        #endif
        Utils_tskAckOrFreeMsg(pMsg, FVID2_EFAIL);
        return;
    }

    //分配link的内存等资源，创建解码线程（调用该函数DecLink_codecCreateProcessTsk(pObj, tskId);）
    status = DecLink_codecCreate(pObj, Utils_msgGetPrm(pMsg));

    Utils_tskAckOrFreeMsg(pMsg, status);

    if (status != FVID2_SOK)
        return;

    Utils_encdecHdvicpPrfInit();
    done = FALSE;
    ackMsg = FALSE;

    while (!done)
    {
        status = Utils_tskRecvMsg(pTsk, &pMsg, BIOS_WAIT_FOREVER);
        if (status != FVID2_SOK)
            break;

        cmd = Utils_msgGetCmd(pMsg);

        switch (cmd)
        {
            case SYSTEM_CMD_NEW_DATA:
                Utils_tskAckOrFreeMsg(pMsg, status);

                flushCmds[0] = SYSTEM_CMD_NEW_DATA;
                Utils_tskFlushMsg(pTsk, flushCmds, 1);
		//link收到数据，调用该函数进行解码
                DecLink_codecProcessData(pObj);
                break;

            case DEC_LINK_CMD_GET_PROCESSED_DATA:
                Utils_tskAckOrFreeMsg(pMsg, status);

                flushCmds[0] = DEC_LINK_CMD_GET_PROCESSED_DATA;
                Utils_tskFlushMsg(pTsk, flushCmds, 1);

                DecLink_codecGetProcessedDataMsgHandler(pObj);
                break;

            case DEC_LINK_CMD_PRINT_IVAHD_STATISTICS:
                Utils_tskAckOrFreeMsg(pMsg, status);

                Utils_encdecHdvicpPrfPrint();
                break;

            case DEC_LINK_CMD_PRINT_STATISTICS:
                DecLink_printStatistics(pObj, TRUE);
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;

            case DEC_LINK_CMD_PRINT_BUFFER_STATISTICS:
                Utils_tskAckOrFreeMsg(pMsg, status);
                DecLink_printBufferStatus(pObj);
                break;

            case DEC_LINK_CMD_DISABLE_CHANNEL:
                {
                    DecLink_ChannelInfo *params;

                    params = (DecLink_ChannelInfo *) Utils_msgGetPrm(pMsg);
                    DecLink_codecDisableChannel(pObj, params);
                    Utils_tskAckOrFreeMsg(pMsg, status);
                }
                break;
            case DEC_LINK_CMD_ENABLE_CHANNEL:
                {
                    DecLink_ChannelInfo *params;

                    params = (DecLink_ChannelInfo *) Utils_msgGetPrm(pMsg);
                    DecLink_codecEnableChannel(pObj, params);
                    Utils_tskAckOrFreeMsg(pMsg, status);
                }
                break;

            case DEC_LINK_CMD_SET_TRICKPLAYCONFIG:
                {
                    DecLink_TPlayConfig * params;
                    params = (DecLink_TPlayConfig *) Utils_msgGetPrm(pMsg);
                    DecLink_setTPlayConfig(pObj, params);
                    Utils_tskAckOrFreeMsg(pMsg, status);
                }
                break;
            case SYSTEM_CMD_STOP:
                DecLink_codecStop(pObj);
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;

            case SYSTEM_CMD_DELETE:
                DecLink_codecStop(pObj);
                done = TRUE;
                ackMsg = TRUE;
                break;

            default:
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;
        }
    }

    DecLink_codecDelete(pObj);

    if (ackMsg && pMsg != NULL)
        Utils_tskAckOrFreeMsg(pMsg, status);

    return;
}

4.3）DecLink_codecProcessData函数从上一个link中获取bit数据，调用videoM3的解码器进行解码；
Int32 DecLink_codecProcessData(DecLink_Obj * pObj)
{
    Int32 status;

    pObj->newDataProcessOnFrameFree = FALSE;
    DecLink_codecQueueBufsToChQue(pObj);

    do
    {
        status = DecLink_codecSubmitData(pObj);
    } while (status == FVID2_SOK);

    return FVID2_SOK;
}


4.4）DecLink_codecQueueBufsToChQue调用System_getLinksFullBufs从prelink中获取bit数据，保存在BitStream_Buf结构中；
static Int32 DecLink_codecQueueBufsToChQue(DecLink_Obj * pObj)
{
    UInt32 bufId, freeBufNum;
    Bitstream_Buf *pBuf;
    System_LinkInQueParams *pInQueParams;
    Bitstream_BufList bufList;
    DecLink_ChObj *pChObj;
    Int32 status;
    UInt32 curTime;

    pInQueParams = &pObj->createArgs.inQueParams;

    System_getLinksFullBufs(pInQueParams->prevLinkId,
                            pInQueParams->prevLinkQueId, &bufList);

    if (bufList.numBufs)
    {
        pObj->inBufGetCount += bufList.numBufs;

        freeBufNum = 0;
        curTime = Utils_getCurTimeInMsec();

        for (bufId = 0; bufId < bufList.numBufs; bufId++)
        {
            pBuf = bufList.bufs[bufId];

            pChObj = &pObj->chObj[pBuf->channelNum];

            pChObj->inFrameRecvCount++;

            // pBuf->fid = pChObj->nextFid;
            if(pChObj->disableChn && pChObj->skipFrame == FALSE)
            {
                pChObj->skipFrame = TRUE;
            }
            else if((pChObj->disableChn == FALSE) && pChObj->skipFrame)
            {
                if(pBuf->isKeyFrame == TRUE)
                {
                    pChObj->skipFrame = FALSE;
                }
            }

            if (((pChObj->IFrameOnlyDecode) &&
                (!pBuf->isKeyFrame)) || pChObj->skipFrame)
            {
                pChObj->inBufSkipCount++;

                pChObj->inFrameUserSkipCount++;

                // Drop if not a I frame
                bufList.bufs[freeBufNum] = pBuf;
                freeBufNum++;
            }
            else
            {
                pChObj->totalInFrameCnt++;
                if (pChObj->totalInFrameCnt > DEC_LINK_STATS_START_THRESHOLD)
                {
                    pChObj->totalFrameIntervalTime +=
                        (curTime - pChObj->prevFrmRecvTime);
                }
                else
                {
                    pChObj->totalFrameIntervalTime = 0;
                    pChObj->totalProcessTime = 0;

                    DecLink_resetStatistics(pObj);
                }
                pChObj->prevFrmRecvTime = curTime;
		
		//将buff压入队列提供解码器
                status = Utils_quePut(&pChObj->inQue, pBuf, BIOS_NO_WAIT);
                UTILS_assert(status == FVID2_SOK);

                pChObj->inBufQueCount++;
            }
        }

        if (freeBufNum)
        {
            bufList.numBufs = freeBufNum;
            System_putLinksEmptyBufs(pInQueParams->prevLinkId,
                                     pInQueParams->prevLinkQueId, &bufList);
            pObj->inBufPutCount += freeBufNum;
        }
    }

    return FVID2_SOK;
}

4.5）System_getLinksFullBufs函数调用systemLink api（pTsk->linkGetFullBitBufs函数）从上一个link获取bit码流数据
Int32 System_getLinksFullBufs(UInt32 linkId, UInt16 queId,
                              Bitstream_BufList * pBufList)
{
    System_LinkObj *pTsk;

    linkId = SYSTEM_GET_LINK_ID(linkId);

    UTILS_assert(linkId < SYSTEM_LINK_ID_MAX);

    pTsk = &gSystem_objCommon.linkObj[linkId];

    if (pTsk->linkGetFullBitBufs != NULL)
        return pTsk->linkGetFullBitBufs(pTsk->pTsk, queId, pBufList);

    return FVID2_EFAIL;
}


4.6）DecLink_codecSubmitData对bit数据进行解码
static Int32 DecLink_codecSubmitData(DecLink_Obj * pObj)
{
    DecLink_ReqObj *pReqObj;
    DecLink_ChObj *pChObj;
    UInt32 chCount,chIdIndex, numProcessCh;
    Bitstream_Buf *pInBuf;
    FVID2_Frame *pOutFrame;
    Int32 status = FVID2_EFAIL, numReqObjPerProcess;
    UInt32 tskId, i;
    static UInt32 startChID = 0;

    System_FrameInfo *pOutFrameInfo;
    UInt32 curTime = Utils_getCurTimeInMsec();

    numProcessCh = 0;
    chIdIndex    = startChID;
    for (chCount = 0; chCount < pObj->inQueInfo.numCh; chCount++,chIdIndex++)
    {
      numReqObjPerProcess = 0;
      if (chIdIndex >= pObj->inQueInfo.numCh)
          chIdIndex = 0;
      pChObj = &pObj->chObj[chIdIndex];
      if (Utils_queIsEmpty(&pObj->outObj.bufOutQue.
                           emptyQue[pChObj->allocPoolID]))
      {
          pObj->newDataProcessOnFrameFree = TRUE;
      }

      while(numReqObjPerProcess < pChObj->numReqObjPerProcess) {
        numReqObjPerProcess++;
        status =
            Utils_queGet(&pObj->reqQue, (Ptr *) & pReqObj, 1,
                         BIOS_NO_WAIT);

        if (UTILS_ISERROR(status)) {
            break;
        }
        pObj->reqQueCount++;
        UTILS_assert(DEC_LINK_MAX_REQ >= pObj->reqQueCount);

        tskId = pObj->ch2ProcessTskId[chIdIndex];
        
        if (pChObj->algObj.algCreateParams.fieldMergeDecodeEnable)
        {
           /* pReqObj->OutFrameList.numFrames should be set to 2 once         */
           /*  codec has support to consume 2 output pointers rather than     */
           /*  just one pointer with 2 contigous fields in field merged       */
           /*  interlaced decode use case.                                    */
            pReqObj->OutFrameList.numFrames = 1;
        }
        else
        {
            pReqObj->OutFrameList.numFrames = 1;
        }
        if ((status == FVID2_SOK) &&
            (pChObj->inBufQueCount) &&
            (Utils_queGetQueuedCount(&pObj->outObj.bufOutQue.emptyQue[pChObj->
                   allocPoolID]) >= pReqObj->OutFrameList.numFrames) &&
            !(Utils_queIsFull(&pObj->decProcessTsk[tskId].processQue)))
        {
            for (i=0; i<pReqObj->OutFrameList.numFrames; i++)
            {
                pOutFrame = NULL;
                status =
                    Utils_bufGetEmptyFrameExt(&pObj->outObj.bufOutQue,
                                              &pOutFrame,
                                              pObj->outObj.ch2poolMap[chIdIndex],
                                              BIOS_NO_WAIT);
                if (pOutFrame)
                {
                    declink_codec_init_outframe(pObj, chIdIndex, pOutFrame);
                    pReqObj->OutFrameList.frames[i] = pOutFrame;
                }
                else
                {
                    break;
                }
            }
            if ((status == FVID2_SOK) && (pOutFrame))
            {
                //获取待解码的数据
                Utils_queGet(&pChObj->inQue, (Ptr *) & pInBuf, 1, BIOS_NO_WAIT);
                UTILS_assert(status == FVID2_SOK);
                pReqObj->InBuf = pInBuf;
                pChObj->inBufQueCount--;

                for (i=0; i<pReqObj->OutFrameList.numFrames; i++)
                {
                    pReqObj->OutFrameList.frames[i]->channelNum =
                                                     pInBuf->channelNum;
                    //pInBuf->timeStamp  = curTime;
                    pReqObj->OutFrameList.frames[i]->timeStamp=
                               pInBuf->timeStamp;


                    pOutFrameInfo = (System_FrameInfo *) pReqObj->OutFrameList.frames[i]->appData;
                    pOutFrameInfo->ts64  = (UInt32)pInBuf->upperTimeStamp;
                    pOutFrameInfo->ts64 <<= 32;
                    pOutFrameInfo->ts64  = pOutFrameInfo->ts64 | ((UInt32)pInBuf->lowerTimeStamp);
                }
                numProcessCh++;
		
		//插入到解码处理队列
                status =
                    Utils_quePut(&pObj->decProcessTsk[tskId].processQue,
                                 pReqObj, BIOS_NO_WAIT);
                UTILS_assert(status == FVID2_SOK);
                pChObj->processReqestCount++;
            }
            else
            {
                status = Utils_quePut(&pObj->reqQue, pReqObj, BIOS_NO_WAIT);
                startChID = chIdIndex;
                UTILS_assert(status == FVID2_SOK);
                pObj->reqQueCount--;
                status = FVID2_EFAIL;
                continue;
            }
        }
        else
        {
            status = Utils_quePut(&pObj->reqQue, pReqObj, BIOS_NO_WAIT);
            UTILS_assert(status == FVID2_SOK);
            pObj->reqQueCount--;
            startChID = chIdIndex;
            status = FVID2_EFAIL;
            if (Utils_queIsEmpty(&pObj->outObj.bufOutQue.
                                 emptyQue[pChObj->allocPoolID]))
            {
                pObj->newDataProcessOnFrameFree = TRUE;
            }
        }
      }
    }

    return status;
}

4.7）DecLink_codecCreateProcessTsk函数
该函数为解码任务函数；从pObj->decProcessTsk[tskId].processQue队列中获取数据，然后进行解码；
static Void DecLink_codecProcessTskFxn(UArg arg1, UArg arg2)
{
    Int32 status, chId, i, j;
    DecLink_Obj *pObj;
    DecLink_ChObj *pChObj;
    DecLink_ReqObj *pReqObj;
    FVID2_FrameList freeFrameList;
    UInt32 tskId;

    pObj = (DecLink_Obj *) arg1;
    tskId = (UInt32) arg2;

    while (pObj->state != SYSTEM_LINK_STATE_STOP)
    {
        pObj->reqObjBatch[tskId].numReqObjsInBatch = 0;
        status = DEC_LINK_S_SUCCESS;
	
        //从队列中获取待解码的数据
        status = Utils_queGet(&pObj->decProcessTsk[tskId].processQue,
                              (Ptr *) & pReqObj, 1, BIOS_WAIT_FOREVER);
        if (!UTILS_ISERROR(status))
        {
            status = DecLink_PrepareBatch (pObj, tskId, pReqObj, 
                                  &pObj->reqObjBatch[tskId]);
            
          if (UTILS_ISERROR(status))
          {
              UTILS_warn("DEC : IVAHDID : %d ENCLINK:ERROR in "
                         "DecLink_SubmitBatch.Status[%d]", tskId, status);
          }
          else 
          {
              /*Log Batch size statistics*/
              pObj->batchStatistics[tskId].numBatchesSubmitted++;
              
              pObj->batchStatistics[tskId].currentBatchSize = pObj->
                reqObjBatch[tskId].numReqObjsInBatch;
              
              if (pObj->batchStatistics[tskId].maxAchievedBatchSize <
                  pObj->batchStatistics[tskId].currentBatchSize)
              {
                pObj->batchStatistics[tskId].maxAchievedBatchSize =
                  pObj->batchStatistics[tskId].currentBatchSize;
              }
                            
              pObj->batchStatistics[tskId].aggregateBatchSize = 
                pObj->batchStatistics[tskId].aggregateBatchSize + 
                pObj->batchStatistics[tskId].currentBatchSize;
               
              pObj->batchStatistics[tskId].averageBatchSize = 
                pObj->batchStatistics[tskId].aggregateBatchSize /
                pObj->batchStatistics[tskId].numBatchesSubmitted;
          }            
        }
        freeFrameList.numFrames = 0;
        if (pObj->reqObjBatch[tskId].numReqObjsInBatch)
        {
            /*Its made sure that for every batch created all ReqObj have the same
            codec. And every Request Batch has atleast one ReqObj */
            chId = pObj->reqObjBatch[tskId].pReqObj[0]->InBuf->channelNum;
            pChObj = &pObj->chObj[chId];
            switch (pChObj->algObj.algCreateParams.format)
            {
                case IVIDEO_H264BP:
                case IVIDEO_H264MP:
                case IVIDEO_H264HP:
                    status = 
                        Declink_h264DecodeFrameBatch(pObj, 
                                                     &pObj->reqObjBatch[tskId],
                                                     &freeFrameList, tskId);
                    if (UTILS_ISERROR(status))
                    {
                         #ifndef DEC_LINK_SUPRESS_ERROR_AND_RESET
                         /*
                         UTILS_warn("DECLINK:ERROR in "
                              "Declink_h264DecodeFrameBatch.Status[%d]", status); 
                         */
                         #endif   
                    }
               break;
         
               case IVIDEO_MPEG4SP:
               case IVIDEO_MPEG4ASP:
                status = Declink_mpeg4DecodeFrameBatch(pObj, 
                                                            &pObj->reqObjBatch[tskId],
                                                            &freeFrameList);
                if (UTILS_ISERROR(status))
                {
                  #ifndef DEC_LINK_SUPRESS_ERROR_AND_RESET
                   UTILS_warn("DECLINK:ERROR in "
                      "Declink_mpeg4DecodeFrameBatch.Status[%d]", status);
                  #endif

                }
               break;

                case IVIDEO_MJPEG:
		   //调用该函数进行解码
                   status = 
                      Declink_jpegDecodeFrameBatch(pObj, 
                                                   &pObj->reqObjBatch[tskId],
                                                   &freeFrameList);
                   if (UTILS_ISERROR(status))
                   {
                       UTILS_warn("DECLINK:ERROR in "
                             "Declink_jpegDecodeFrameBatch.Status[%d]", status);
                   }
                   
                 break;

                default:
                    UTILS_assert(FALSE);
            }
        }
        for (i = 0; i < pObj->reqObjBatch[tskId].numReqObjsInBatch; i++)
        {
            pReqObj = pObj->reqObjBatch[tskId].pReqObj[i];

            for (j = 0; j < pReqObj->OutFrameList.numFrames; j++)
            {
                FVID2_Frame *displayFrame;

                    DecLink_codecGetDisplayFrame(pObj,
                                             pReqObj->OutFrameList.frames[j],
                                             &freeFrameList, &displayFrame);
                    pReqObj->OutFrameList.frames[j] = displayFrame;

            }
	    
	    //将解码后的数据插入到队列，主函数会调用DecLink_codecGetProcessedDataMsgHandler函数对数据进行处理，发给下一个link；
            status = Utils_quePut(&pObj->processDoneQue, pReqObj,
                                  BIOS_NO_WAIT);
            UTILS_assert(status == FVID2_SOK);
        }
        
        DecLink_codecFreeProcessedFrames(pObj, &freeFrameList);
    }

    return;
}


4.8）jpeg解码函数（Declink_jpegDecodeFrameBatch）如下：
Int32 Declink_jpegDecodeFrameBatch(DecLink_Obj * pObj,
                                   DecLink_ReqBatch * pReqObjBatch,
                                   FVID2_FrameList * freeFrameList)
{
    int error = XDM_EFAIL, reqObjIdx, chId;
    Int32 i, freeBufIdx, prosIdx;
    IJPEGVDEC_InArgs *inArgs;
    IJPEGVDEC_OutArgs *outArgs;
    XDM2_BufDesc *inputBufDesc;
    XDM2_BufDesc *outputBufDesc;
    IJPEGVDEC_Handle handle;
    IALG_Fxns *fxns = NULL;
    FVID2_Frame *outFrame = NULL;
    IVIDEO2_BufDesc *displayBufs = NULL;
    UInt32 bytesConsumed;
    DecLink_ReqObj *pReqObj;
    DecLink_ChObj *pChObj;
    System_FrameInfo *pFrameInfo;

    /*Make sure that the Req Object is not empty*/
    UTILS_assert (pReqObjBatch->numReqObjsInBatch > 0);
    
    for (reqObjIdx = 0; reqObjIdx < pReqObjBatch->numReqObjsInBatch; reqObjIdx++)
    {
        pReqObj = pReqObjBatch->pReqObj[reqObjIdx];
        chId = pReqObj->InBuf->channelNum;
        pChObj = &pObj->chObj[chId];
        
        inArgs = &pChObj->algObj.u.jpegAlgIfObj.inArgs;
        outArgs = &pChObj->algObj.u.jpegAlgIfObj.outArgs;
        inputBufDesc = &pChObj->algObj.u.jpegAlgIfObj.inBufs;
        outputBufDesc = &pChObj->algObj.u.jpegAlgIfObj.outBufs;
        handle = pChObj->algObj.u.jpegAlgIfObj.algHandle;
        
        UTILS_assert(handle != NULL);
        
        fxns = (IALG_Fxns *) handle->fxns;


        //IRESMAN_HDVICP2_EarlyAcquire((IALG_Handle) handle,
        //                             pChObj->algObj.u.jpegAlgIfObj.ivaChID);

        bytesConsumed = 0;

        for (prosIdx=0; prosIdx< pReqObj->OutFrameList.numFrames; prosIdx++)
        {
            /*----------------------------------------------------------------*/
            /* Initialize the input ID in input arguments to the bufferid of  */
            /* buffer element returned from getfreebuffer() function.         */
            /*----------------------------------------------------------------*/
            /* inputID & numBytes need to update before every decode call */

            if (FALSE == outArgs->viddecOutArgs.outBufsInUseFlag)
            {
                outFrame = pReqObj->OutFrameList.frames[prosIdx];
            }
            else
            {
                UTILS_assert(NULL != pChObj->algObj.prevOutFrame);
                /* Previous buffer was in use. Free the current outBuf */
                outFrame = pChObj->algObj.prevOutFrame;
                freeFrameList->frames[freeFrameList->numFrames] = 
                                pReqObj->OutFrameList.frames[prosIdx];
                pChObj->numBufsInCodec--;
                freeFrameList->numFrames++;
            }

            inArgs->viddecInArgs.inputID = (UInt32) outFrame;
            inArgs->viddecInArgs.numBytes = pReqObj->InBuf->fillLength - 
                                                            bytesConsumed;

            for (i = 0; i < inputBufDesc->numBufs; i++)
            {
                /* Set proper buffer addresses for bitstreamn data */
                /*---------------------------------------------------------------*/
                inputBufDesc->descs[i].buf = (XDAS_Int8 *) pReqObj->InBuf->addr 
                                                           +  bytesConsumed;
                inputBufDesc->descs[i].bufSize.bytes = pReqObj->InBuf->bufSize;
            }

            for (i = 0; i < outputBufDesc->numBufs; i++)
            {
                /* Set proper buffer addresses for Frame data */
                /*------------------------------------------------------------*/
                if (pChObj->algObj.algCreateParams.tilerEnable)
                {
                    outputBufDesc->descs[i].buf =
                        (Ptr)
                        Utils_tilerAddr2CpuAddr((UInt32) (outFrame->addr[0][i]));
                }
                else
                {
                    outputBufDesc->descs[i].buf = outFrame->addr[0][i];
                }
            }
          
            fxns->algActivate((IALG_Handle) handle);

	    //调用visa api进行jpeg解码
            error = handle->fxns->ividdec.process((IVIDDEC3_Handle) handle,
                                                  inputBufDesc,
                                                  outputBufDesc,
                                                  (IVIDDEC3_InArgs *) inArgs,
                                                  (IVIDDEC3_OutArgs *) outArgs);
            fxns->algDeactivate((IALG_Handle) handle);
            bytesConsumed = outArgs->viddecOutArgs.bytesConsumed;
            if (error != XDM_EOK)
            {
                DECLINK_INTERNAL_ERROR_LOG(error, "ALGPROCESS FAILED:STATUS");
            }
            pChObj->algObj.prevOutFrame = outFrame;
            pReqObj->status = error;
            pReqObj->OutFrameList.frames[prosIdx] = NULL;
            UTILS_assert(outArgs->viddecOutArgs.displayBufsMode ==
                         IVIDDEC3_DISPLAYBUFS_EMBEDDED);
            displayBufs = &(outArgs->viddecOutArgs.displayBufs.bufDesc[0]);
            if ((outArgs->viddecOutArgs.outputID[0] != 0)
                && (displayBufs->numPlanes))
            {
                XDAS_Int8 *pExpectedBuf;

                pReqObj->OutFrameList.frames[prosIdx] =
                  (FVID2_Frame *) outArgs->viddecOutArgs.outputID[0];
                if (pChObj->algObj.algCreateParams.tilerEnable)
                {
                    pExpectedBuf = (Ptr) Utils_tilerAddr2CpuAddr(
                        (UInt32) pReqObj->OutFrameList.frames[prosIdx]->addr[0][0]);
                }
                else
                {
                    pExpectedBuf = pReqObj->OutFrameList.frames[prosIdx]->addr[0][0];
                }
                UTILS_assert(displayBufs->planeDesc[0].buf == pExpectedBuf);
                /* Enable this code once SysTemFrameInfo is updated with support
                 * for storing frame resolution info */
                pFrameInfo = (System_FrameInfo *) 
                             pReqObj->OutFrameList.frames[prosIdx]->appData;
                {
                    UTILS_assert(pFrameInfo != NULL);
                    pFrameInfo->rtChInfo.width =
                        displayBufs->activeFrameRegion.bottomRight.x -
                        displayBufs->activeFrameRegion.topLeft.x;
                    pFrameInfo->rtChInfo.height =
                        displayBufs->activeFrameRegion.bottomRight.y -
                        displayBufs->activeFrameRegion.topLeft.y;
                    pFrameInfo->rtChInfo.pitch[0] = displayBufs->imagePitch[0];
                    pFrameInfo->rtChInfo.pitch[1] = displayBufs->imagePitch[1];
                    pFrameInfo->rtChInfoUpdate = TRUE;
                }
                pReqObj->OutFrameList.frames[prosIdx]->fid =
                    Utils_encdecMapXDMContentType2FVID2FID(displayBufs->
                                                           contentType);
            }
            freeBufIdx = 0;
            while (outArgs->viddecOutArgs.freeBufID[freeBufIdx] != 0)
            {
                freeFrameList->frames[freeFrameList->numFrames] =
                  (FVID2_Frame *) outArgs->viddecOutArgs.freeBufID[freeBufIdx];
                freeFrameList->numFrames++;
                pChObj->numBufsInCodec--;
                freeBufIdx++;
            }
        }
    
	}

    return (error);
}

4.9）DecLink_codecGetProcessedDataMsgHandler函数功能获取解码后的数据，该函数在DecLink_tskMain中调用；
Int32 DecLink_codecGetProcessedDataMsgHandler(DecLink_Obj * pObj)
{
    Int32 status;

    status = DecLink_codecGetProcessedData(pObj);
    UTILS_assert(status == FVID2_SOK);

    return DEC_LINK_S_SUCCESS;

}

4.10）DecLink_codecGetProcessedData 处理解码后的数据，发给下一个link


static Int32 DecLink_codecGetProcessedData(DecLink_Obj * pObj)
{
    Bitstream_BufList inBufList;
    FVID2_FrameList outFrameList;
    FVID2_FrameList outFrameSkipList;
    UInt32 chId, sendCmd;
    System_LinkInQueParams *pInQueParams;
    DecLink_ChObj *pChObj;
    DecLink_ReqObj *pReqObj;
    Int32 status, j;
    UInt32 curTime;

    sendCmd = FALSE;
    inBufList.numBufs = 0;
    inBufList.appData = NULL;
    outFrameList.numFrames = 0;
    outFrameSkipList.numFrames = 0;
    curTime = Utils_getCurTimeInMsec();

    while(!Utils_queIsEmpty(&pObj->processDoneQue)
          &&
          (inBufList.numBufs < (VIDBITSTREAM_MAX_BITSTREAM_BUFS - 1))
          &&
          (outFrameList.numFrames < (FVID2_MAX_FVID_FRAME_PTR - 1)))
    {
	//获取解码后的数据
        status = Utils_queGet(&pObj->processDoneQue, (Ptr *) & pReqObj, 1,
                              BIOS_NO_WAIT);
        if (status != FVID2_SOK)
        {
            break;
        }

        UTILS_assert(pReqObj->InBuf != NULL);
        chId = pReqObj->InBuf->channelNum;
        pChObj = &pObj->chObj[chId];

        //if (pChObj->totalInFrameCnt > DEC_LINK_STATS_START_THRESHOLD)
        {
            if (curTime > pReqObj->InBuf->timeStamp)
            {
                pChObj->totalProcessTime +=
                     (curTime - pReqObj->InBuf->timeStamp);
            }
        }

        pChObj->getProcessedBufCount++;

        pChObj->outFrameCount++;

        inBufList.bufs[inBufList.numBufs] = pReqObj->InBuf;
        inBufList.numBufs++;

        for (j = 0; j < pReqObj->OutFrameList.numFrames; j++)
        {
            if (pReqObj->OutFrameList.frames[j])
            {
                UTILS_assert(pReqObj->InBuf->channelNum ==
                             pReqObj->OutFrameList.frames[j]->channelNum);
                UTILS_assert(pChObj->allocPoolID < UTILS_BUF_MAX_ALLOC_POOLS);


                pChObj->trickPlayObj.skipFrame = Utils_doSkipFrame(&(pChObj->trickPlayObj.frameSkipCtx));

                if (pChObj->trickPlayObj.skipFrame == TRUE)
                {
                    /* Skip the output frame */
                    outFrameSkipList.frames[outFrameSkipList.numFrames] =
                                        pReqObj->OutFrameList.frames[j];
                    outFrameSkipList.numFrames++;
                }
                else
                {
                    outFrameList.frames[outFrameList.numFrames] =
                                        pReqObj->OutFrameList.frames[j];
                    outFrameList.numFrames++;
                }
            }
        }
	//归还队列；
        status = Utils_quePut(&pObj->reqQue, pReqObj, BIOS_NO_WAIT);
        UTILS_assert(status == FVID2_SOK);
        pObj->reqQueCount--;
    }

    if (outFrameList.numFrames)
    {
	//解码后的数据，压入到队列，供下一个link使用
        status = Utils_bufPutFullExt(&pObj->outObj.bufOutQue,
                                     &outFrameList);
        UTILS_assert(status == FVID2_SOK);
        sendCmd = TRUE;
    }

    if (outFrameSkipList.numFrames)
    {
        status = DecLink_codecFreeProcessedFrames(pObj, &outFrameSkipList);
        UTILS_assert(status == DEC_LINK_S_SUCCESS);
    }

    if (inBufList.numBufs)
    {
        /* Free input frames */
        pInQueParams = &pObj->createArgs.inQueParams;
        System_putLinksEmptyBufs(pInQueParams->prevLinkId,
                                 pInQueParams->prevLinkQueId, &inBufList);
        pObj->inBufPutCount += inBufList.numBufs;
    }

    /* Send-out the output bitbuffer */
    if (sendCmd == TRUE)
    {
	//往下一个link发送消息，告诉下一个link数据已经准备好了
        System_sendLinkCmd(pObj->createArgs.outQueParams.nextLink,
                           SYSTEM_CMD_NEW_DATA);
    }

    return FVID2_SOK;
}


4.11）Utils_bufPutFullExt 就是将buff压入到输出full队列，然后提供api供外部的其他link使用；
Int32 Utils_bufPutFullExt(Utils_BufHndlExt * pHndl, 
                          FVID2_FrameList * pFrameList)
{
    UInt32 idx;
    Int32 status;

    UTILS_assert(pHndl != NULL);
    UTILS_assert(pFrameList != NULL);
    UTILS_assert(pFrameList->numFrames <= FVID2_MAX_FVID_FRAME_PTR);

    for (idx = 0; idx < pFrameList->numFrames; idx++)
    {
        status =
            Utils_quePut(&pHndl->fullQue, pFrameList->frames[idx],
                         BIOS_NO_WAIT);
        UTILS_assert(status == FVID2_SOK);
    }

    return FVID2_SOK;
}

4.12）DecLink_getFullFrames 函数提供外部调用，获取解码后的帧数据；

Int32 DecLink_getFullFrames(Utils_TskHndl * pTsk, UInt16 queId,
                            FVID2_FrameList * pFrameList)
{
    DecLink_Obj *pObj = (DecLink_Obj *) pTsk->appData;

    UTILS_assert(queId < DEC_LINK_MAX_OUT_QUE);

    return Utils_bufGetFullExt(&pObj->outObj.bufOutQue, pFrameList,
                               BIOS_NO_WAIT);
}

在解码器初始化函数已经注册了该回调函数
     linkObj.linkGetFullFrames = DecLink_getFullFrames;

在下一个link调用preLink的该函数获取解码后的数据；


5)IpcFrameOutM3
5.1）IpcFramesOutLink_tskMain函数中调用 IpcFramesOutLink_processFrameBufs获取解码后的数据；
Void IpcFramesOutLink_tskMain(struct Utils_TskHndl * pTsk, Utils_MsgHndl * pMsg)
{
    UInt32 cmd = Utils_msgGetCmd(pMsg);
    Bool ackMsg, done;
    Int32 status;
    IpcFramesOutLink_Obj *pObj = (IpcFramesOutLink_Obj *) pTsk->appData;

    if (cmd != SYSTEM_CMD_CREATE)
    {
        Utils_tskAckOrFreeMsg(pMsg, FVID2_EFAIL);
        return;
    }

    status = IpcFramesOutLink_create(pObj, Utils_msgGetPrm(pMsg));

    Utils_tskAckOrFreeMsg(pMsg, status);

    if (status != FVID2_SOK)
        return;

    done = FALSE;
    ackMsg = FALSE;

    while (!done)
    {
        status = Utils_tskRecvMsg(pTsk, &pMsg, BIOS_WAIT_FOREVER);
        if (status != FVID2_SOK)
            break;

        cmd = Utils_msgGetCmd(pMsg);

        switch (cmd)
        {
            case SYSTEM_CMD_DELETE:
                done = TRUE;
                ackMsg = TRUE;
                break;
            case SYSTEM_CMD_NEW_DATA:
                Utils_tskAckOrFreeMsg(pMsg, status);

                IpcFramesOutLink_processFrameBufs(pObj);
                IpcFramesOutLink_releaseFrameBufs(pObj);
                break;

            case IPCFRAMESOUTRTOS_LINK_CMD_SET_FRAME_RATE:
                {
                    IpcOutM3Link_ChFpsParams *params;

                    params = (IpcOutM3Link_ChFpsParams *) Utils_msgGetPrm(pMsg);
                    IpcFramesOutLink_SetFrameRate(pObj, params);
                    Utils_tskAckOrFreeMsg(pMsg, status);
                }
                break;

            case IPCFRAMESOUTRTOS_LINK_CMD_PRINT_STATISTICS:
                IpcFramesOutLink_printStatistics(pObj, TRUE);
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;


            case SYSTEM_IPC_CMD_RELEASE_FRAMES:
                Utils_tskAckOrFreeMsg(pMsg, status);

#ifdef SYSTEM_DEBUG_IPC_RT
                Vps_printf(" %d: IPC_FRAMES_OUT   : Received Notify !!!\n",
                           Utils_getCurTimeInMsec());
#endif

                IpcFramesOutLink_releaseFrameBufs(pObj);
                break;

            default:
                Utils_tskAckOrFreeMsg(pMsg, status);
                break;
        }
    }

    IpcFramesOutLink_delete(pObj);

#ifdef SYSTEM_DEBUG_IPC_FRAMES_OUT
    Vps_printf(" %d: IPC_FRAMES_OUT   : Delete Done !!!\n", Utils_getCurTimeInMsec());
#endif

    if (ackMsg && pMsg != NULL)
        Utils_tskAckOrFreeMsg(pMsg, status);

    return;
}


5.2）IpcFramesOutLink_processFrameBufs获取数据；


Int32 IpcFramesOutLink_processFrameBufs(IpcFramesOutLink_Obj * pObj)
{
    System_LinkInQueParams *pInQueParams;
    FVID2_FrameList bufList;
    FVID2_Frame *pFrameBuf = NULL;
    SystemIpcFrames_ListElem *pListElem;
    Int32 status;
    Int32 bufId;
    UInt32 curTime;
    FVID2_FrameList freeFrameBufList;
    UInt8 queId;
    UInt32 sendMsgToTsk = 0;
    UInt32 chPerQueue;
    IpcFramesOutLink_ChObj *pChObj;

    pInQueParams = &pObj->createArgs.baseCreateParams.inQueParams;

    bufList.numFrames = 0;

    //下面函数是从解码link获取数据，数据保存在bufList中；
    System_getLinksFullFrames(pInQueParams->prevLinkId,
                            pInQueParams->prevLinkQueId, &bufList);

    freeFrameBufList.numFrames = 0;
    curTime = Utils_getCurTimeInMsec();
    if (bufList.numFrames)
    {
#ifdef SYSTEM_DEBUG_IPC_RT
        Vps_printf(" %d: IPC_FRAMES_OUT   : Received %d framebufs !!!\n",
                   Utils_getCurTimeInMsec(), bufList.numFrames);
#endif

        UTILS_assert(bufList.numFrames <= FVID2_MAX_FVID_FRAME_PTR);
        pObj->stats.recvCount += bufList.numFrames;
        sendMsgToTsk = 0;
        chPerQueue =
            (pObj->numCh / pObj->createArgs.baseCreateParams.numOutQue);

#ifdef IPC_FRAMES_IN_ENABLE_PROFILE
        Utils_prfTsBegin(pObj->stats.tsHandle);
#endif                                                     /* IPC_FRAMES_IN_ENABLE_PROFILE
                                                            */
        pObj->totalFrameCount += bufList.numFrames;
        for (bufId = 0; bufId < bufList.numFrames; bufId++)
        {
            Bool          doFrameDrop;

            pFrameBuf = bufList.frames[bufId];
            UTILS_assert(pFrameBuf != NULL);

            pChObj = &pObj->chObj[pFrameBuf->channelNum];
            pChObj->inFrameRecvCount++;
            doFrameDrop = Utils_doSkipFrame(&(pChObj->frameSkipCtx));

            /* frame skipped due to user setting */
            if(doFrameDrop)
            {
                pChObj->inFrameUserSkipCount++;
                UTILS_assert(freeFrameBufList.numFrames <
                             FVID2_MAX_FVID_FRAME_PTR);
                freeFrameBufList.frames[freeFrameBufList.numFrames] =
                    pFrameBuf;
                freeFrameBufList.numFrames++;
                pObj->stats.droppedCount++;
                continue;
            }

            queId = (pFrameBuf->channelNum / chPerQueue);
	    //从队列中取一个buff，赋值给pListElem
            status =
                Utils_queGet(&pObj->listElemQue, (Ptr *) & pListElem, 1,
                             BIOS_NO_WAIT);
            UTILS_assert(!UTILS_ISERROR(status));
            if (status != FVID2_SOK)
            {
                /* normally this condition should not happen, if it happens
                 * return the framebuf back to its generator */
#if 0
                Vps_printf(" IPC_OUT: Dropping framebuf\n");
#endif

                UTILS_assert(freeFrameBufList.numFrames <
                             FVID2_MAX_FVID_FRAME_PTR);
                freeFrameBufList.frames[freeFrameBufList.numFrames] =
                    pFrameBuf;
                freeFrameBufList.numFrames++;
                pObj->stats.droppedCount++;
                pChObj->inFrameUserSkipCount++;
                continue;
            }
            UTILS_assert(SYSTEM_IPC_FRAMES_GET_BUFSTATE(pListElem->bufState)
                         == IPC_FRAMEBUF_STATE_FREE);
            UTILS_assert(SYSTEM_IPC_FRAMES_GET_BUFOWNERPROCID(pListElem->bufState)
                         == System_getSelfProcId());
            SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
                                         IPC_FRAMEBUF_STATE_ALLOCED);
            IpcFramesOutLink_copyFrameBufInfo2ListElem(pObj, pListElem, pFrameBuf);
            pFrameBuf->timeStamp = curTime;
            SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
                                         IPC_FRAMEBUF_STATE_OUTQUE);
            sendMsgToTsk |= (1 << queId);
	    
	    //压入到ListMP，提供给IpcFrameInLink(A8)调用；
            status =
                ListMP_putTail(pObj->listMPOutHndl, (ListMP_Elem *) pListElem);
            UTILS_assert(status == ListMP_S_SUCCESS);
            pChObj->inFrameProcessCount++;
        }

#ifdef IPC_FRAMES_IN_ENABLE_PROFILE
        Utils_prfTsEnd(pObj->stats.tsHandle, bufList.numFrames);
#endif                                                     /* IPC_FRAMES_IN_ENABLE_PROFILE
                                                            */

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

        /* ProcessLink enable, send the notification to processLink else send to next Link */
        //发送通知；
	
        if (pObj->createArgs.baseCreateParams.processLink != SYSTEM_LINK_ID_INVALID)
        {
            if (pObj->createArgs.baseCreateParams.notifyProcessLink)
            {
                System_ipcSendNotify(pObj->createArgs.baseCreateParams.processLink);
            }
        }
        else
        {
            for (queId = 0; queId < pObj->createArgs.baseCreateParams.numOutQue; queId++)
            {
                if ((pObj->createArgs.baseCreateParams.notifyNextLink) && (sendMsgToTsk & 0x1))
                {
                    System_ipcSendNotify(pObj->createArgs.baseCreateParams.outQueParams[queId].
                        nextLink);
                }
                sendMsgToTsk >>= 1;
                if (sendMsgToTsk == 0)
                    break;
            }
        }

        if (pObj->createArgs.baseCreateParams.noNotifyMode)
        {
            if (FALSE == pObj->prd.clkStarted)
            {
                IpcFramesOutLink_startPrdObj(pObj,
                                           IPC_FRAMESOUT_LINK_DONE_PERIOD_MS,
                                           FALSE);
            }
        }
    }

    return FVID2_SOK;
}


7)IpcFrameInHost（A8）
A8如何获取到数据；

7.1）IpcFramesInLink_tskMain 函数
static
Int IpcFramesInLink_tskMain(struct OSA_TskHndl * pTsk, OSA_MsgHndl * pMsg,
                            Uint32 curState)
{
    UInt32 cmd = OSA_msgGetCmd(pMsg);
    Bool ackMsg, done;
    Int status = IPC_FRAMES_IN_LINK_S_SUCCESS;
    IpcFramesInLink_Obj *pObj = (IpcFramesInLink_Obj *) pTsk->appData;

    OSA_printf("%s:Entered", __func__);

    if (cmd != SYSTEM_CMD_CREATE)
    {
        OSA_tskAckOrFreeMsg(pMsg, OSA_EFAIL);
        return status;
    }

    status = IpcFramesInLink_create(pObj, OSA_msgGetPrm(pMsg));

    OSA_tskAckOrFreeMsg(pMsg, status);

    if (status != OSA_SOK)
        return status;

    done = FALSE;
    ackMsg = FALSE;

    while (!done)
    {
        status = OSA_tskWaitMsg(pTsk, &pMsg);
        if (status != OSA_SOK)
            break;

        cmd = OSA_msgGetCmd(pMsg);

        switch (cmd)
        {
            case SYSTEM_CMD_DELETE:
                done = TRUE;
                ackMsg = TRUE;
                break;
            case SYSTEM_CMD_NEW_DATA:
                OSA_tskAckOrFreeMsg(pMsg, status);
                //OSA_assert(pObj->prd.numPendingCmd > 0);
                OSA_mutexLock(&pObj->prd.mutexPendingCmd);
                pObj->prd.numPendingCmd--;
                OSA_mutexUnlock(&pObj->prd.mutexPendingCmd);
                //从ipcOutLink中获取数据
                IpcFramesInLink_processFrameBufs(pObj);
                break;
            case SYSTEM_CMD_STOP:
                IpcFramesInLink_stop(pObj);
                OSA_tskAckOrFreeMsg(pMsg, status);
                break;
            default:
                OSA_tskAckOrFreeMsg(pMsg, status);
                break;
        }
    }

    IpcFramesInLink_delete(pObj);

#ifdef SYSTEM_DEBUG_IPC_FRAMES_IN
    OSA_printf(" %d: IPC_FRAMES_IN   : Delete Done !!!\n", OSA_getCurTimeInMsec());
#endif

    if (ackMsg && pMsg != NULL)
        OSA_tskAckOrFreeMsg(pMsg, status);

    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}

7.2）IpcFramesInLink_processFrameBufs 调用ListMP_getHead获取listElem，然后
static
Int32 IpcFramesInLink_processFrameBufs(IpcFramesInLink_Obj * pObj)
{
    VIDFrame_Buf *pFrameBuf;
    SystemIpcFrames_ListElem *pListElem;
    UInt32 numFrameBufs;
    Int32 status;
    UInt32 curTime;

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

        IpcFramesInLink_getFrameBuf(pObj, pListElem, &pFrameBuf);
        OSA_assert(SYSTEM_IPC_FRAMES_GET_BUFSTATE(pListElem->bufState)
                     == IPC_FRAMEBUF_STATE_OUTQUE);
        pListElem->timeStamp = curTime;
        pListElem->frameBuf.linkPrivate = (Ptr)pListElem;
        SYSTEM_IPC_FRAMES_SET_BUFOWNERPROCID(pListElem->bufState);
        SYSTEM_IPC_FRAMES_SET_BUFSTATE(pListElem->bufState,
                                     IPC_FRAMEBUF_STATE_DEQUEUED);
        pObj->stats.recvCount++;
	//压入队列
        status = OSA_quePut(&pObj->outFrameBufQue,
                            (Int32)pFrameBuf, OSA_TIMEOUT_NONE);
        OSA_assert(status == OSA_SOK);

        numFrameBufs++;
    }

#ifdef SYSTEM_DEBUG_IPC_RT
    OSA_printf(" %d: IPC_FRAMES_IN   : Recevived %d framebufs !!!\n",
               OSA_getCurTimeInMsec(), numFrameBufs);
#endif

    if (numFrameBufs)
    {
        if (pObj->createArgs.cbFxn)
        {
            pObj->createArgs.cbFxn(pObj->createArgs.cbCtx);
        }
    }

    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}

7.3）IpcFramesInLink_getFullFrames提供给外部api使用(IpcFramesInLink_getFullVideoFrames函数)
static
Int32 IpcFramesInLink_getFullFrames(IpcFramesInLink_Obj * pObj,
                                    VIDFrame_BufList * pFrameBufList)
{
    UInt32 idx;
    Int32 status;
    VIDFrame_Buf *pFrame;

    for (idx = 0; idx < VIDFRAME_MAX_FRAME_BUFS; idx++)
    {
        status =
            OSA_queGet(&pObj->outFrameBufQue, (Int32 *) & pFrame,
                       OSA_TIMEOUT_NONE);
        if (status != OSA_SOK)
            break;
        pFrameBufList->frames[idx] = *pFrame;
    }

    pFrameBufList->numFrames = idx;

    return IPC_FRAMES_IN_LINK_S_SUCCESS;
}