• State Resolved
  • Locked Locked
  • Replies 7 replies
  • Subscribers 98 subscribers
  • Views 317 views
  • Users 0 members are here
Support feedback
Options
Options
Related

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

8168 RDK4.0 264 streams cannot be obtained

Ri-Ping YU
Expert 1460 points

Hi, everybody

I'm using 8168 with RDK 4.0. In my usecase, there are 4 cameras, 1 PCIe video source, 3 Swms(2 for HD, 1 for SD ), 4 encoding path(1camera, 1 PCIe(with no video source currently), 1 HD Swms and its scaling channel)

Encoding part of my chain is depicted below

The issue:

The callback function of the IpcBitsInHost LINK has never executed, that is , there is no h264 stream be produced.

But the source codes is same as in RDK3.0, it can work properly in 3.0.

How can I fix this issue?

Appreciate for any reply!

  • 0
    TI__Guru 59700 points

    Are you not receiving even a single ipcBitsInLink callback or does it stop after sometime ? Share you RDK 4.0 usecase file and logs of Vsys_printDetailedStatistics and Vsys_printBufferStatistics when issue occurs

  • 0 in reply to Badri Narayanan
    Expert 1460 points

    ipcBitsInLink callback function can execute 8 times at startup, then stops.

    My usecase file

    Fullscreen 1643.Chain_ES_ITC_0_02_00_1.c Download 
    /************************************************************************************
*   Copyright(C), 20130411, TsingTao EastSoft										*
*   FileName:		Chain_ES_ITC_0_02_00_1.c										*
*   Author:			MA Dong-Mei, YU Ri-Ping											*
*   Version:		0.02.00.1														*
*   Date:			20130411														*
*   Description:	Main LINK Chain													*
*   Function List:																	*
*   History:																		*
************************************************************************************/

#include <demos/link_api_demos/common/common.h>
#include <demos/link_api_demos/channels/channels.h>
#include <demos/link_api_demos/pic_treat/swms.h>
#include <demos/link_api_demos/log/log.h>
#include <demos/link_api_demos/task_a8/ipcBits.h>
#include <demos/link_api_demos/task_a8/chains_ipcFrames.h>
#include <demos/link_api_demos/interface/ControllingInterface.h>
#include <demos/link_api_demos/voice_stimulate/esvoiceStimulate.h>
#include <demos/link_api_demos/interface/set_osd.h>
#include <demos/link_api_demos/pic_treat/osd.h>
#include <mcfw/interfaces/link_api/system_common.h>
#include <demos/link_api_demos/configure/system_param.h>

#include <osa.h>

#include <link_api/system.h>
#include <link_api/captureLink.h>
#include <link_api/deiLink.h>
#include <link_api/nsfLink.h>
#include <link_api/algLink.h>
#include <link_api/displayLink.h>
#include <link_api/nullLink.h>
#include <link_api/grpxLink.h>
#include <link_api/dupLink.h>
#include <link_api/swMsLink.h>
#include <link_api/selectLink.h>
#include <link_api/sclrLink.h>
#include <link_api/mergeLink.h>
#include <link_api/nullSrcLink.h>
#include <link_api/ipcLink.h>
#include <link_api/systemLink_m3vpss.h>
#include <link_api/systemLink_m3video.h>
#include <link_api/encLink.h>
#include <link_api/decLink.h>

#include <ti/xdais/xdas.h>
#include <ti/xdais/dm/xdm.h>
#include <ti/xdais/dm/ivideo.h>
#include <ih264enc.h>
#include <ih264vdec.h>

static OSD_WinTextInfoM font = {
      	        SYSTEM_DF_YUV422I_YUYV,
      	        {100,32},
      	        FONTSIZE48_48_24,
      	        YELLOW,
      	        TRANSPARENTBACKGROUND,
      	        720
      	    };

static OSD_WinTextInfoM Ip_font = {
      	        SYSTEM_DF_YUV422I_YUYV,
      	        {100,128},
      	        FONTSIZE48_48_24,
      	        WHITE,
      	        TRANSPARENTBACKGROUND,
      	        720
      	    };

  Ptr               osdWinSrAddr[ALG_LINK_OSD_MAX_CH][CHAINS_OSD_NUM_WINDOWS];
  Ptr               osdWinBuPtr[ALG_LINK_OSD_MAX_CH][CHAINS_OSD_NUM_WINDOWS];
  Ptr               osdWinSrAddr1[ALG_LINK_OSD_MAX_CH][CHAINS_OSD_NUM_WINDOWS];
  Ptr               osdWinBuPtr1[ALG_LINK_OSD_MAX_CH][CHAINS_OSD_NUM_WINDOWS];

  static SystemVideo_Ivahd2ChMap_Tbl systemVid_encDecIvaChMapTbl =
  {
      .isPopulated = 1,
      .ivaMap[0] =
      {
          .EncNumCh  = 1,
          .EncChList = {4},
          .DecNumCh  = 1,
          .DecChList = {0},
      },
      .ivaMap[1] =
      {
          .EncNumCh  = 2,
          .EncChList = {0, 2},
          .DecNumCh  = 0,
          .DecChList = {0},
      },
      .ivaMap[2] =
      {
          .EncNumCh  = 2,
          .EncChList = {1, 3},
          .DecNumCh  = 0,
          .DecChList = {0},
      },
  };

IpcBitsOutLinkHLOS_CreateParams  	esipcBitsOutHostPrm0;
IpcBitsInLinkRTOS_CreateParams   	esipcBitsInVideoPrm0;
DecLink_CreateParams             	esdecPrm0;
IpcLink_CreateParams              	esipcOutVideoPrm0;
IpcLink_CreateParams              	esipcInVpssPrm0;

IpcFramesOutLinkHLOS_CreateParams    esipcFramesOutHostPrm0;
IpcFramesInLinkRTOS_CreateParams     esipcFramesInVpssPrm0;

CaptureLink_CreateParams  		  	escapturePrm;
CaptureLink_VipInstParams 		  	*espCaptureInstPrm;
CaptureLink_OutParams     		  	*espCaptureOutPrm;
MergeLink_CreateParams    		  	esmergePrm0;

IpcFramesOutLinkRTOS_CreateParams   esipcFramesOutVpssPrm0;
IpcFramesInLinkRTOS_CreateParams    esipcFramesInDspPrm0;
AlgLink_CreateParams                esosdPrm0;

DupLink_CreateParams			  	esdupPrm2;
SwMsLink_CreateParams             	esswMsPrm[HD_DISPLAY_NUMBER];

IpcFramesOutLinkRTOS_CreateParams   esipcFramesOutVpssPrm1;
IpcFramesInLinkRTOS_CreateParams    esipcFramesInDspPrm1;
AlgLink_CreateParams                esosdPrm1;

DupLink_CreateParams              	esdupPrm[HD_DISPLAY_NUMBER];
DisplayLink_CreateParams          	esdisplayPrm[HD_DISPLAY_NUMBER];
MergeLink_CreateParams				esmergePrm1;
DupLink_CreateParams				esdupPrm3;
SelectLink_CreateParams				esselPrm0;
SelectLink_CreateParams				esselPrm1;
SclrLink_CreateParams	            essclrPrm0;
MergeLink_CreateParams				esmergePrm2;
SelectLink_CreateParams				esselPrm2;
NullLink_CreateParams				esnullPrm0;
SwMsLink_CreateParams             	esswMsPrm2;
DisplayLink_CreateParams          	esdisplayPrm2;
NsfLink_CreateParams        		esnsfPrm0;
IpcLink_CreateParams                esipcOutVpssPrm0;
IpcLink_CreateParams                esipcInVideoPrm0;
EncLink_CreateParams                esencPrm0;
IpcBitsOutLinkRTOS_CreateParams     esipcBitsOutVideoPrm0;
IpcBitsInLinkHLOS_CreateParams      esipcBitsInHostPrm0;

SwMsLink_CreateParams * swMsPrmList[2] = { esswMsPrm, esswMsPrm + 1 };

//////////////////////////////////////////////////////////////////////////////////////////////////////

UInt32 esipcBitsOutHostId0;
UInt32 esipcBitsInVideoId0;
UInt32 esdecId0;
UInt32 esipcOutVideoId0;
UInt32 esipcInVpssId0;

UInt32 esipcFramesOutHostId0;
UInt32 esipcFramesInVpssId0;

UInt32 escaptureId, esvipInstId;
UInt32 esmergeId0;
UInt32 esipcFramesOutVpssId0, esipcFramesInDspId0, esosdId0;
UInt32 esdupId2;
UInt32 esswMsId[HD_DISPLAY_NUMBER];
UInt32 esipcFramesOutVpssId1, esipcFramesInDspId1, esosdId1;
UInt32 esdupId[HD_DISPLAY_NUMBER];
UInt32 esdisplayId[HD_DISPLAY_NUMBER];
UInt32 esmergeId1;
UInt32 esdupId3;
UInt32 esselId0;
UInt32 esselId1;
UInt32 essclrId0;
UInt32 esmergeId2;
UInt32 esselId2;
UInt32 esnullId0;
UInt32 esswMsId2;
UInt32 esdisplayId2;
UInt32 esnsfId0;
UInt32 esipcOutVpssId0;
UInt32 esipcInVideoId0;
UInt32 esencId0;
UInt32 esipcBitsOutVideoId0;
UInt32 esipcBitsInHostId0;

static void Demo_updateTime(int signo)
{
    static struct tm tmCur;
    time_t timeval;
    char osdStr[40];
    Int32 chId;
    AlgLink_OsdWindowPrm TimeWindowPrm ;

    static int count =	15;

    for(chId = 0; chId < 1 ;chId ++)
    {
        switch(signo)
        {
            case SIGALRM:
            	if (count >= 0)
            	{
            		count --;
            	}
                if (count == 0)
                {
                	AlgLink_OsdChWinParams *chWinPrm  =		&esosdPrm1.osdChCreateParams[chId].chDefaultParams;
                	chWinPrm->winPrm[4].globalAlpha            = FALSE;
                	System_linkControl(esosdId1, ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM, chWinPrm, sizeof(AlgLink_OsdChWinParams), TRUE);
                }

                time(&timeval);
                localtime_r(&timeval, &tmCur);
                sprintf(osdStr,"%04d-%02d-%02d %02d:%02d:%02d",
                		tmCur.tm_year+1900, tmCur.tm_mon+1, tmCur.tm_mday, tmCur.tm_hour, tmCur.tm_min, tmCur.tm_sec);
                osdDrawText(osdStr,font,(char*)osdWinBuPtr1[chId][3],&TimeWindowPrm,0);

                if( uart_commu_info.voiceStimulate_flag == TRUE)
                {
                	if (vsResetDownCounter > 0)
                	{
                		vsResetDownCounter --;

                		if (0 == vsResetDownCounter)
                		{
                			SwMsMapChtoWin(esswMsId[0], 0, 0x00, &esswMsPrm[0]);
                			SwMsMapChtoWin(esswMsId[0], 1, 0x01, &esswMsPrm[0]);
                			SwMsMapChtoWin(esswMsId[0], 2, 0x02, &esswMsPrm[0]);
                			SwMsMapChtoWin(esswMsId[0], 3, 0x03, &esswMsPrm[0]);
                			SwMsMapChtoWin(esswMsId[0], 4, 0x10, &esswMsPrm[0]);
                			SwMsMapChtoWin(esswMsId[0], 5, 0x20, &esswMsPrm[0]);
                		}
                	}
                }

                if ((osdSupInfo.bOnDisplay) && (osdSupInfo.lDurationTimeSec > 0))
                {
                	osdSupInfo.lDurationTimeSec --;
                	if (0 == osdSupInfo.lDurationTimeSec)
                	{
                		AlgLink_OsdChWinParams * chWinPrm  = &esosdPrm1.osdChCreateParams[0].chDefaultParams;

                		int i;
                		for (i = 0; i < 3; i ++)
                		{
                			chWinPrm->winPrm[i].globalAlpha		=	FALSE;
                			System_linkControl(esosdId1, ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM,
                					chWinPrm, sizeof(AlgLink_OsdChWinParams), TRUE);
                		}

                		osdSupInfo.bOnDisplay			=	FALSE;
                		osdSupInfo.lDurationTimeSec		=	-1;
                	}
                }

                break;
            default:
                break;
        }
    }
}


Void Chain_ES_ITC_0_02_00_1(P_CHANNEL_DISCRIPTOR pChannels)
{
    UInt32        chId,winId;
    unsigned char test[MAX_INPUT_STR_SIZE];
    OSD_WinTextInfoM font2 = {
          	        SYSTEM_DF_YUV422I_YUYV,
          	        {400,96},
          	        FONTSIZE32_32_16,
          	        YELLOW,
          	        TRANSPARENTBACKGROUND,
          	        720
          	    };
    OSD_WinTextInfoM        dynamicFont,swmsFont;
	Position                OSDposition[4] =
	                        {
								{100,32},
		    					{1800,32},
		    					{100,600},
		    					{2000,600}
						    };

    unsigned int length;
    struct itimerval oneSec;

    UInt32 displayVector[LEN_DISPLAY_VECTOR];
    P_HCHANNEL_NODE pHChannelNode = NULL;
    P_HENCODER_NODE pHEncoderNode = NULL;
    GLOBE_CHANNEL_MATRIX gChMat;
    UInt32 i;
    Char   ch;

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    CI_Start();

    IpcFramesInit();

    IPCBitsOutDataStructInit(&ipc_ctrl);
    IPCBitsOutCoreThreadsStart(&ipc_ctrl);

    IPCBitsInDataStructInit(&ipc_ctrl);
    IPCBitsEnvironmentInit(&ipc_ctrl);
    PeripheralProcessEncodedDataStart();
    IPCBitsInCoreCopyThreadsStart();

    uart_init(&uart_commu_info);
    voiceStimulateCreate(&uart_commu_info);
    UartVolumCreate(&uart_commu_info);

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    CHAINS_INIT_STRUCT(IpcBitsOutLinkHLOS_CreateParams,esipcBitsOutHostPrm0);
    CHAINS_INIT_STRUCT(IpcBitsInLinkRTOS_CreateParams,esipcBitsInVideoPrm0);
    CHAINS_INIT_STRUCT(DecLink_CreateParams,esdecPrm0);
    CHAINS_INIT_STRUCT(IpcLink_CreateParams,esipcOutVideoPrm0);
    CHAINS_INIT_STRUCT(IpcLink_CreateParams,esipcInVpssPrm0);

    CHAINS_INIT_STRUCT(IpcFramesOutLinkHLOS_CreateParams,esipcFramesOutHostPrm0);
    CHAINS_INIT_STRUCT(IpcFramesInLinkRTOS_CreateParams,esipcFramesInVpssPrm0);

    CaptureLink_CreateParams_Init(&escapturePrm);

    CHAINS_INIT_STRUCT(IpcFramesInLinkRTOS_CreateParams,esipcFramesInDspPrm0);
    CHAINS_INIT_STRUCT(IpcFramesOutLinkRTOS_CreateParams,esipcFramesOutVpssPrm0);

    CHAINS_INIT_STRUCT(IpcFramesInLinkRTOS_CreateParams,esipcFramesInDspPrm1);
    CHAINS_INIT_STRUCT(IpcFramesOutLinkRTOS_CreateParams,esipcFramesOutVpssPrm1);

    for (i=0; i<HD_DISPLAY_NUMBER; i++)
    {
        CHAINS_INIT_STRUCT(SwMsLink_CreateParams,esswMsPrm[i]);
        CHAINS_INIT_STRUCT(DisplayLink_CreateParams,esdisplayPrm[i]);
    }
    CHAINS_INIT_STRUCT(SelectLink_CreateParams,esselPrm0);
    CHAINS_INIT_STRUCT(SelectLink_CreateParams,esselPrm1);
    SclrLink_CreateParams_Init (&essclrPrm0);
    CHAINS_INIT_STRUCT(SelectLink_CreateParams,esselPrm2);
    CHAINS_INIT_STRUCT(SwMsLink_CreateParams,esswMsPrm2);
    CHAINS_INIT_STRUCT(DisplayLink_CreateParams,esdisplayPrm2);
    CHAINS_INIT_STRUCT(NsfLink_CreateParams,esnsfPrm0);
    CHAINS_INIT_STRUCT(IpcLink_CreateParams,esipcOutVpssPrm0);
    CHAINS_INIT_STRUCT(IpcLink_CreateParams,esipcInVideoPrm0);
    CHAINS_INIT_STRUCT(EncLink_CreateParams,esencPrm0);
    CHAINS_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams,esipcBitsOutVideoPrm0);
    CHAINS_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,esipcBitsInHostPrm0);

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    esipcBitsOutHostId0   = SYSTEM_HOST_LINK_ID_IPC_BITS_OUT_0;
    esipcBitsInVideoId0   = SYSTEM_VIDEO_LINK_ID_IPC_BITS_IN_0;
    esdecId0              = SYSTEM_LINK_ID_VDEC_0;
    esipcOutVideoId0      = SYSTEM_VIDEO_LINK_ID_IPC_OUT_M3_0;
    esipcInVpssId0        = SYSTEM_VPSS_LINK_ID_IPC_IN_M3_0;

    esipcFramesOutHostId0  = SYSTEM_HOST_LINK_ID_IPC_FRAMES_OUT_0;
    esipcFramesInVpssId0   = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_IN_0;

    escaptureId     		= SYSTEM_LINK_ID_CAPTURE;
    esmergeId0      		= SYSTEM_VPSS_LINK_ID_MERGE_0;

    esipcFramesOutVpssId0   = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_OUT_0;
    esipcFramesInDspId0     = SYSTEM_DSP_LINK_ID_IPC_FRAMES_IN_0;
    esosdId0                = SYSTEM_LINK_ID_ALG_0;

    esdupId2				= SYSTEM_VPSS_LINK_ID_DUP_2;
    esswMsId[0]             = SYSTEM_LINK_ID_SW_MS_MULTI_INST_0;
    esswMsId[1]             = SYSTEM_LINK_ID_SW_MS_MULTI_INST_1;

    esipcFramesOutVpssId1  = SYSTEM_VPSS_LINK_ID_IPC_FRAMES_OUT_1;
    esipcFramesInDspId1    = SYSTEM_DSP_LINK_ID_IPC_FRAMES_IN_1;
    esosdId1               = SYSTEM_LINK_ID_ALG_1;

    esdupId[0]      		= SYSTEM_VPSS_LINK_ID_DUP_0;
    esdupId[1]      		= SYSTEM_VPSS_LINK_ID_DUP_1;
    esdisplayId[0]          = SYSTEM_LINK_ID_DISPLAY_0;
    esdisplayId[1]          = SYSTEM_LINK_ID_DISPLAY_1;
    esmergeId1	  		    = SYSTEM_VPSS_LINK_ID_MERGE_1;
    esdupId3				= SYSTEM_VPSS_LINK_ID_DUP_3;
    esselId0                = SYSTEM_VPSS_LINK_ID_SELECT_0;
    esselId1                = SYSTEM_VPSS_LINK_ID_SELECT_1;
    essclrId0				= SYSTEM_LINK_ID_SCLR_INST_0;
    esmergeId2			    = SYSTEM_VPSS_LINK_ID_MERGE_2;
    esselId2                = SYSTEM_VPSS_LINK_ID_SELECT_2;
    esnullId0				= SYSTEM_VPSS_LINK_ID_NULL_0;
    esswMsId2				= SYSTEM_LINK_ID_SW_MS_MULTI_INST_2;
    esdisplayId2			= SYSTEM_LINK_ID_DISPLAY_2;
    esnsfId0         		= SYSTEM_LINK_ID_NSF_0;
    esipcOutVpssId0  		= SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0;
    esipcInVideoId0  		= SYSTEM_VIDEO_LINK_ID_IPC_IN_M3_0;
    esencId0         		= SYSTEM_LINK_ID_VENC_0;
    esipcBitsOutVideoId0   = SYSTEM_VIDEO_LINK_ID_IPC_BITS_OUT_0;
    esipcBitsInHostId0     = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_0;

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    System_linkControl(
        SYSTEM_LINK_ID_M3VIDEO,
        SYSTEM_COMMON_CMD_SET_CH2IVAHD_MAP_TBL,
        &systemVid_encDecIvaChMapTbl,
        sizeof(SystemVideo_Ivahd2ChMap_Tbl),
        TRUE
    );

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    GetDisplayVector(pChannels, displayVector);
    Chains_displayCtrlInit(displayVector);

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    System_LinkQueInfo queInfo;
    queInfo.numCh = GetStreamNum(pChannels);
    for (pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_STREAM]->next, i = 0;
    		pHChannelNode && (i < GetStreamNum(pChannels));
    		pHChannelNode = pHChannelNode->next, i ++)
    {
        queInfo.chInfo[i].bufType           = SYSTEM_BUF_TYPE_VIDBITSTREAM;
        queInfo.chInfo[i].codingformat      = pHChannelNode->body.hChannel->entity.stream.format;
        queInfo.chInfo[i].height            = pHChannelNode->body.hChannel->entity.stream.height;
        queInfo.chInfo[i].width             = pHChannelNode->body.hChannel->entity.stream.width;
        queInfo.chInfo[i].memType           = SYSTEM_MT_TILEDMEM;
        queInfo.chInfo[i].dataFormat        = SYSTEM_DF_YUV420P;
        queInfo.chInfo[i].scanFormat        = Vsys_isStdInterlaced(pHChannelNode->body.hChannel->entity.stream.std) ?
                                              SYSTEM_SF_INTERLACED : SYSTEM_SF_PROGRESSIVE;
    }

    esipcBitsOutHostPrm0.baseCreateParams.numOutQue                    = 1;
    esipcBitsOutHostPrm0.baseCreateParams.numChPerOutQue[0]            = GetStreamNum(pChannels);
    esipcBitsOutHostPrm0.baseCreateParams.outQueParams[0].nextLink     = esipcBitsInVideoId0;
//    esipcBitsOutHostPrm0.bufPoolPerCh                                  = FALSE;
//    esipcBitsOutHostPrm0.numBufPerCh[0]                                = 16;
    //modified according to 4.0 user guidance, maybe cannot work properly, promotion is needed...
    for (i = 0; i < GetStreamNum(pChannels); i ++)
    {
    	esipcBitsOutHostPrm0.totalBitStreamBufferSize[i]	=	8;
    	esipcBitsOutHostPrm0.maxQueueDepth[i]				=	6;
    	esipcBitsOutHostPrm0.chMaxReqBufSize[0]				=	(720 * 576) / 2;
    }
    IPCBitsOutHLOS_Params_Init(&esipcBitsOutHostPrm0, &queInfo);

    esipcBitsInVideoPrm0.baseCreateParams.inQueParams.prevLinkId       = esipcBitsOutHostId0;
    esipcBitsInVideoPrm0.baseCreateParams.inQueParams.prevLinkQueId    = 0;
    esipcBitsInVideoPrm0.baseCreateParams.numOutQue                    = 1;
    esipcBitsInVideoPrm0.baseCreateParams.numChPerOutQue[0]            = GetStreamNum(pChannels);
    esipcBitsInVideoPrm0.baseCreateParams.outQueParams[0].nextLink     = esdecId0;
    IPCBitsInRTOS_Params_Init(&esipcBitsInVideoPrm0);

    for (pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_STREAM]->next, i = 0;
    		pHChannelNode && (i < GetStreamNum(pChannels));
    		pHChannelNode = pHChannelNode->next, i ++)
    {
        esdecPrm0.chCreateParams[i].format							   = pHChannelNode->body.hChannel->entity.stream.format;
        esdecPrm0.chCreateParams[i].profile                              = IH264VDEC_PROFILE_ANY;
        esdecPrm0.chCreateParams[i].targetMaxWidth                       = pHChannelNode->body.hChannel->entity.stream.width;
        esdecPrm0.chCreateParams[i].targetMaxHeight                      = pHChannelNode->body.hChannel->entity.stream.height;
        esdecPrm0.chCreateParams[i].fieldMergeDecodeEnable               = FALSE;
        esdecPrm0.chCreateParams[i].algCreateStatus                      = DEC_LINK_ALG_CREATE_STATUS_CREATE;
        esdecPrm0.chCreateParams[i].defaultDynamicParams.targetFrameRate = pHChannelNode->body.hChannel->entity.stream.frameRate;
        esdecPrm0.chCreateParams[i].defaultDynamicParams.targetBitRate   = pHChannelNode->body.hChannel->entity.stream.targetBitRate;
        esdecPrm0.chCreateParams[i].numBufPerCh                          = 16;
        esdecPrm0.chCreateParams[i].algCreateStatus	                  	 =	TRUE;
        esdecPrm0.chCreateParams[i].tilerEnable							 =	TRUE;
    }
    esdecPrm0.inQueParams.prevLinkId    = esipcBitsInVideoId0;
    esdecPrm0.inQueParams.prevLinkQueId = 0;
    esdecPrm0.outQueParams.nextLink     = esipcOutVideoId0;

    esipcOutVideoPrm0.inQueParams.prevLinkId    = esdecId0;
    esipcOutVideoPrm0.inQueParams.prevLinkQueId = 0;
    esipcOutVideoPrm0.numOutQue                 = 1;
    esipcOutVideoPrm0.outQueParams[0].nextLink  = esipcInVpssId0;
    esipcOutVideoPrm0.notifyNextLink            = TRUE;
    esipcOutVideoPrm0.notifyPrevLink            = FALSE;
    esipcOutVideoPrm0.noNotifyMode              = FALSE;

    esipcInVpssPrm0.inQueParams.prevLinkId      = esipcOutVideoId0;
    esipcInVpssPrm0.inQueParams.prevLinkQueId   = 0;
    esipcInVpssPrm0.numOutQue                   = 1;
    esipcInVpssPrm0.outQueParams[0].nextLink    = esmergeId0;
    esipcInVpssPrm0.notifyNextLink              = TRUE;
    esipcInVpssPrm0.notifyPrevLink              = TRUE;
    esipcInVpssPrm0.noNotifyMode                = FALSE;

    esipcFramesOutHostPrm0.baseCreateParams.inQueParams.prevLinkId         = SYSTEM_LINK_ID_INVALID;
    esipcFramesOutHostPrm0.baseCreateParams.inQueParams.prevLinkQueId      = 0;
    esipcFramesOutHostPrm0.baseCreateParams.numOutQue                      = 1;
    esipcFramesOutHostPrm0.baseCreateParams.numChPerOutQue[0]              = 1;
    esipcFramesOutHostPrm0.baseCreateParams.outQueParams[0].nextLink       = esipcFramesInVpssId0;
    esipcFramesOutHostPrm0.baseCreateParams.inputFrameRate                 = 60;
    esipcFramesOutHostPrm0.baseCreateParams.outputFrameRate                = 60;
    esipcFramesOutHostPrm0.baseCreateParams.notifyNextLink                 = TRUE;
    esipcFramesOutHostPrm0.baseCreateParams.notifyPrevLink                 = FALSE;
    esipcFramesOutHostPrm0.baseCreateParams.notifyProcessLink              = FALSE;
    esipcFramesOutHostPrm0.baseCreateParams.noNotifyMode                   = FALSE;

    esipcFramesOutHostPrm0.inQueInfo.numCh                                 = 1;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].startX                      = 0;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].startY                      = 0;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].height                      = 720;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].width                       = 1280;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].pitch[0]                    = 2560;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].bufType                     = SYSTEM_BUF_TYPE_VIDFRAME;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].codingformat                = IVIDEO_H264HP;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].memType                     = SYSTEM_MT_NONTILEDMEM;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].dataFormat                  = SYSTEM_DF_YUV422I_YUYV;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].scanFormat                  = SYSTEM_SF_PROGRESSIVE;
    System_linkCreate(esipcFramesOutHostId0, &esipcFramesOutHostPrm0, sizeof(esipcFramesOutHostPrm0));

    esipcFramesInVpssPrm0.baseCreateParams.inQueParams.prevLinkId      = esipcFramesOutHostId0;
    esipcFramesInVpssPrm0.baseCreateParams.inQueParams.prevLinkQueId   = 0;
    esipcFramesInVpssPrm0.baseCreateParams.inputFrameRate              = 60;
    esipcFramesInVpssPrm0.baseCreateParams.noNotifyMode                = FALSE;
    esipcFramesInVpssPrm0.baseCreateParams.notifyNextLink              = TRUE;
    esipcFramesInVpssPrm0.baseCreateParams.notifyPrevLink              = TRUE;
    esipcFramesInVpssPrm0.baseCreateParams.numOutQue                   = 1;
    esipcFramesInVpssPrm0.baseCreateParams.numChPerOutQue[0]           = 1;
    esipcFramesInVpssPrm0.baseCreateParams.outQueParams[0].nextLink    = esmergeId0;
    esipcFramesInVpssPrm0.baseCreateParams.outputFrameRate             = 60;

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    escapturePrm.isPalMode                		= 	FALSE;
    escapturePrm.numVipInst               		= 	GetCameraNum(pChannels);
    escapturePrm.tilerEnable              		= 	FALSE;
    escapturePrm.fakeHdMode						=	FALSE;
    escapturePrm.enableSdCrop					= 	FALSE;
    escapturePrm.doCropInCapture          		= 	FALSE;
    escapturePrm.numBufsPerCh             		= 	16;
    escapturePrm.numExtraBufs             		=	0;
    escapturePrm.maxBlindAreasPerCh       		= 	0;
    escapturePrm.overrideNumBufsInInstPrms		=	FALSE;

    for (pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_CAMERA]->next, i = 0; pHChannelNode && (i < GetCameraNum(pChannels));
    		pHChannelNode = pHChannelNode->next, i ++)
    {
        espCaptureInstPrm                     	= 	&escapturePrm.vipInst[i];

        espCaptureInstPrm->vipInstId          	= 	(SYSTEM_CAPTURE_INST_VIP0_PORTA + i) % SYSTEM_CAPTURE_INST_MAX;
        espCaptureInstPrm->videoCaptureMode		=	SYSTEM_CAPT_VIDEO_CAPTURE_MODE_SINGLE_CH_NON_MUX_DISCRETE_SYNC_ACTVID_VSYNC;
        espCaptureInstPrm->videoIfMode			=	SYSTEM_CAPT_VIDEO_IF_MODE_8BIT;
        espCaptureInstPrm->inScanFormat			=	SYSTEM_SF_PROGRESSIVE;
        espCaptureInstPrm->videoDecoderId     	= 	0;
        espCaptureInstPrm->inDataFormat       	= 	SYSTEM_DF_YUV422P;
        espCaptureInstPrm->standard          	= 	pHChannelNode->body.hChannel->entity.camera.std;
        espCaptureInstPrm->numOutput          	= 	1;
        espCaptureInstPrm->numChPerOutput     	= 	1;
        espCaptureInstPrm->enableTimestampInInterrupt	=	TRUE;
        espCaptureInstPrm->numBufsPerCh			=	16;
        espCaptureInstPrm->muxModeStartChId		=	0;

        espCaptureOutPrm                      	= &espCaptureInstPrm->outParams[0];
        espCaptureOutPrm->dataFormat          	= SYSTEM_DF_YUV422I_YUYV;
        espCaptureOutPrm->scEnable            	= FALSE;
        espCaptureOutPrm->outQueId            	= 0;

        espCaptureInstPrm->useAdvancedParams		=	FALSE;
    }
    escapturePrm.outQueParams[0].nextLink     = esmergeId0;

    System_linkCreate(escaptureId, &escapturePrm, sizeof(escapturePrm));

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    esmergePrm0.numInQue                       = 3;
    esmergePrm0.inQueParams[0].prevLinkId      = escaptureId;
    esmergePrm0.inQueParams[0].prevLinkQueId   = 0;
    esmergePrm0.inQueParams[1].prevLinkId      = esipcFramesInVpssId0;
    esmergePrm0.inQueParams[1].prevLinkQueId   = 0;
    esmergePrm0.inQueParams[2].prevLinkId      = esipcInVpssId0;
    esmergePrm0.inQueParams[2].prevLinkQueId   = 0;
    esmergePrm0.outQueParams.nextLink          = esipcFramesOutVpssId0;
    esmergePrm0.notifyNextLink                 = TRUE;

    ///////////////////////////////////////////////////  O  S  D  //////////////////////////////////////////////////////////////////////////

    esipcFramesOutVpssPrm0.baseCreateParams.inQueParams.prevLinkId     = esmergeId0;
    esipcFramesOutVpssPrm0.baseCreateParams.inQueParams.prevLinkQueId  = 0;
    esipcFramesOutVpssPrm0.baseCreateParams.numOutQue                  = 1;
    esipcFramesOutVpssPrm0.baseCreateParams.outQueParams[0].nextLink   = esdupId2;
    esipcFramesOutVpssPrm0.baseCreateParams.processLink                = esipcFramesInDspId0;
    esipcFramesOutVpssPrm0.baseCreateParams.noNotifyMode               = FALSE;
    esipcFramesOutVpssPrm0.baseCreateParams.notifyPrevLink             = FALSE;
    esipcFramesOutVpssPrm0.baseCreateParams.notifyNextLink             = TRUE;
    esipcFramesOutVpssPrm0.baseCreateParams.notifyProcessLink          = TRUE;

    esipcFramesInDspPrm0.baseCreateParams.inQueParams.prevLinkId       = esipcFramesOutVpssId0;
    esipcFramesInDspPrm0.baseCreateParams.inQueParams.prevLinkQueId    = 0;
    esipcFramesInDspPrm0.baseCreateParams.numOutQue                    = 1;
    esipcFramesInDspPrm0.baseCreateParams.outQueParams[0].nextLink     = esosdId0;
    esipcFramesInDspPrm0.baseCreateParams.noNotifyMode                 = FALSE;
    esipcFramesInDspPrm0.baseCreateParams.notifyPrevLink               = FALSE;
    esipcFramesInDspPrm0.baseCreateParams.notifyNextLink               = TRUE;

    esosdPrm0.enableOSDAlg                     = TRUE;
    esosdPrm0.enableSCDAlg                     = FALSE;
    esosdPrm0.inQueParams.prevLinkId           = esipcFramesInDspId0;
    esosdPrm0.inQueParams.prevLinkQueId        = 0;

    //////////////////////////////////////////////////  O  S  D  ///////////////////////////////////////////////////////////////////////////////

    esdupPrm2.inQueParams.prevLinkId		=	esipcFramesOutVpssId0;
    esdupPrm2.inQueParams.prevLinkQueId		=	0;
    esdupPrm2.numOutQue						=	3;
    esdupPrm2.outQueParams[0].nextLink		=	esswMsId[0];
    esdupPrm2.outQueParams[1].nextLink		=	esswMsId[1];
    esdupPrm2.outQueParams[2].nextLink		=	esmergeId1;
    esdupPrm2.notifyNextLink				=	TRUE;

    for (pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_SWMS]->next, i = 0;
    		pHChannelNode && (i < 2);
    		pHChannelNode = pHChannelNode->next, i ++)
    {
   		esswMsPrm[i].numSwMsInst			= 2;
    	esswMsPrm[i].swMsInstId[0]         	= SYSTEM_SW_MS_SC_INST_DEIHQ_SC_NO_DEI;
    	esswMsPrm[i].swMsInstStartWin[0]	= 0;
   		esswMsPrm[i].swMsInstId[1]         	= SYSTEM_SW_MS_SC_INST_DEI_SC_NO_DEI;
    	esswMsPrm[i].swMsInstStartWin[1]	= 3;

        esswMsPrm[i].inQueParams.prevLinkId    = esdupId2;
        esswMsPrm[i].inQueParams.prevLinkQueId = i;
        if (0 == i)
        {
        	esswMsPrm[i].outQueParams.nextLink     = esipcFramesOutVpssId1;
        }
        else
        {
        	esswMsPrm[i].outQueParams.nextLink     = esdupId[i];
        }
        esswMsPrm[i].lineSkipMode              = FALSE;
        esswMsPrm[i].enableLayoutGridDraw      = TRUE;
        esswMsPrm[i].layoutPrm.outputFPS       = pHChannelNode->body.hChannel->entity.swms.frameRate;
        esswMsPrm[i].maxInputQueLen            = 64;
        esswMsPrm[i].maxOutRes                 = pHChannelNode->body.hChannel->entity.swms.std;
        esswMsPrm[i].numOutBuf                 = 256;
        esswMsPrm[i].outputBufModified			=	TRUE;

        SwMsSetLayoutParams(esswMsId[i], pHChannelNode->body.hChannel->entity.swms.info.hd_info.currlayout, &esswMsPrm[i]);

        if (0 == i)
        {
			esdupPrm[i].inQueParams.prevLinkId           = esipcFramesOutVpssId1;
			esdupPrm[i].inQueParams.prevLinkQueId        = 0;
        }
        else
        {
			esdupPrm[i].inQueParams.prevLinkId           = esswMsId[i];
			esdupPrm[i].inQueParams.prevLinkQueId        = 0;
        }
      	esdupPrm[i].numOutQue                 	   	 = 2;
        esdupPrm[i].outQueParams[0].nextLink         = esdisplayId[i];
        esdupPrm[i].outQueParams[1].nextLink         = esmergeId1;
        esdupPrm[i].notifyNextLink                   = TRUE;

        //////////////////////////////////////////////////  O  S  D  //////////////////////////////////////////////////////////////////////////

        esipcFramesOutVpssPrm1.baseCreateParams.inQueParams.prevLinkId     = esswMsId[0];
        esipcFramesOutVpssPrm1.baseCreateParams.inQueParams.prevLinkQueId  = 0;
        esipcFramesOutVpssPrm1.baseCreateParams.numOutQue                  = 1;
        esipcFramesOutVpssPrm1.baseCreateParams.outQueParams[0].nextLink   = esdupId[0];
        esipcFramesOutVpssPrm1.baseCreateParams.processLink                = esipcFramesInDspId1;
        esipcFramesOutVpssPrm1.baseCreateParams.noNotifyMode               = FALSE;
        esipcFramesOutVpssPrm1.baseCreateParams.notifyPrevLink             = TRUE;
        esipcFramesOutVpssPrm1.baseCreateParams.notifyNextLink             = TRUE;
        esipcFramesOutVpssPrm1.baseCreateParams.notifyProcessLink          = TRUE;

        esipcFramesInDspPrm1.baseCreateParams.inQueParams.prevLinkId       = esipcFramesOutVpssId1;
        esipcFramesInDspPrm1.baseCreateParams.inQueParams.prevLinkQueId    = 0;
        esipcFramesInDspPrm1.baseCreateParams.numOutQue                    = 1;
        esipcFramesInDspPrm1.baseCreateParams.outQueParams[0].nextLink     = esosdId1;
        esipcFramesInDspPrm1.baseCreateParams.noNotifyMode                 = FALSE;
        esipcFramesInDspPrm1.baseCreateParams.notifyPrevLink               = TRUE;
        esipcFramesInDspPrm1.baseCreateParams.notifyNextLink               = TRUE;

        esosdPrm1.enableOSDAlg                     = TRUE;
        esosdPrm1.enableSCDAlg                     = FALSE;
        esosdPrm1.inQueParams.prevLinkId           = esipcFramesInDspId1;
        esosdPrm1.inQueParams.prevLinkQueId        = 0;
        for(chId = 0; chId < 1; chId++)
        {
            esosdPrm1.osdChCreateParams[chId].maxWidth    = CHAINS_OSD_WIN_MAX_WIDTH;
            esosdPrm1.osdChCreateParams[chId].maxHeight   = CHAINS_OSD_WIN_MAX_HEIGHT;

            AlgLink_OsdChWinParams * chWinPrm1       = &esosdPrm1.osdChCreateParams[chId].chDefaultParams;

            chWinPrm1->chId                          = chId;
            chWinPrm1->numWindows                    = 5;
            chWinPrm1->colorKey[0]                   = COLORKEY;
            chWinPrm1->colorKey[1]                   = COLORKEY;
            chWinPrm1->colorKey[2]                   = COLORKEY;
            for(winId = 0; winId < chWinPrm1->numWindows ;winId++)

            {
            	chWinPrm1->winPrm[winId].format             = SYSTEM_DF_YUV422I_YUYV;
            	chWinPrm1->winPrm[winId].transperencyEnable = CHAINS_OSD_TRANSPARENCY;
       	        chWinPrm1->winPrm[winId].enableWin          = FALSE;
       	        chWinPrm1->winPrm[winId].globalAlpha        = CHAINS_OSD_GLOBAL_ALPHA;

                Chains_createBuf(&chWinPrm1->winPrm[winId].addr[0][0],
       	                   &osdWinBuPtr1[chId][winId], &osdWinSrAddr1[chId][winId],
       	                   MAX_YUVBUF_SIZE, 0);
                if (winId == 3)
                {
                	chWinPrm1->winPrm[winId].enableWin          = CHAINS_OSD_ENABLE_WIN;
                	osdDrawText("1999-12-23 00:00:00",font,(char*)osdWinBuPtr1[chId][winId],&chWinPrm1->winPrm[winId],FALSE);
                }

                if (winId == 4)
                {
                	system_get_ip();
              	    char  OSDIP[30] = "IP: ";
              	    strcat(OSDIP,set_ip_param_conf->address);
              	    chWinPrm1->winPrm[winId].enableWin          = CHAINS_OSD_ENABLE_WIN;
              	    osdDrawText(OSDIP,Ip_font,(char*)osdWinBuPtr1[chId][winId],&chWinPrm1->winPrm[winId],FALSE);
                }
            }
        }

        {
            signal(SIGALRM, Demo_updateTime);
            oneSec.it_value.tv_sec = 1;
            oneSec.it_value.tv_usec = 0;
            oneSec.it_interval.tv_sec = 1;
            oneSec.it_interval.tv_usec = 0;
            setitimer(ITIMER_REAL, &oneSec, NULL);
        }
        //////////////////////////////////////////////////  O  S  D  ///////////////////////////////////////////////////////////////////////////////

        esdisplayPrm[i].numInputQueues                = 1;
        esdisplayPrm[i].activeQueue                   = 0;
        esdisplayPrm[i].inQueParams[0].prevLinkId     = esdupId[i];
        esdisplayPrm[i].inQueParams[0].prevLinkQueId  = 0;
        esdisplayPrm[i].displayRes                    = pHChannelNode->body.hChannel->entity.swms.std;
        esdisplayPrm[i].forceFieldSeparatedInputMode  = FALSE;
    }

    esmergePrm1.numInQue		=	3;
    esmergePrm1.inQueParams[0].prevLinkId		=	esdupId2;
    esmergePrm1.inQueParams[0].prevLinkQueId	=	2;
    esmergePrm1.inQueParams[1].prevLinkId		=	esdupId[0];
    esmergePrm1.inQueParams[1].prevLinkQueId	=	1;
    esmergePrm1.inQueParams[2].prevLinkId		=	esdupId[1];
    esmergePrm1.inQueParams[2].prevLinkQueId	=	1;
    esmergePrm1.outQueParams.nextLink			=	esdupId3;
    esmergePrm1.notifyNextLink	=	TRUE;

    esdupPrm3.inQueParams.prevLinkId			=	esmergeId1;
    esdupPrm3.inQueParams.prevLinkQueId		=	0;
    esdupPrm3.numOutQue						=	3;
    esdupPrm3.outQueParams[0].nextLink		=	esselId0;
    esdupPrm3.outQueParams[1].nextLink		=	esselId1;
    esdupPrm3.outQueParams[2].nextLink		=	esselId2;
    esdupPrm3.notifyNextLink					=	TRUE;

    esselPrm0.inQueParams.prevLinkId       = esdupId3;
    esselPrm0.inQueParams.prevLinkQueId    = 0;
    esselPrm0.numOutQue                    = 2;
    esselPrm0.outQueParams[0].nextLink     = esmergeId2;
    esselPrm0.outQueChInfo[0].outQueId     = 0;
    esselPrm0.outQueChInfo[0].numOutCh     = GetRawEncoderNum(pChannels);
    esselPrm0.outQueParams[1].nextLink     = esnullId0;
    esselPrm0.outQueChInfo[1].outQueId     = 1;
    esselPrm0.outQueChInfo[1].numOutCh     = GetChannelsNum(pChannels) - 1 - GetRawEncoderNum(pChannels);

	GetGlobeChannelSelMatrixRawEnc(pChannels, &gChMat);

	for (i=0; i<gChMat.encChNum; i++)
	{
		esselPrm0.outQueChInfo[0].inChNum[i] = gChMat.channel[0][i];
	}
	for (i=0; i<gChMat.nonencChNum; i++)
	{
		esselPrm0.outQueChInfo[1].inChNum[i] = gChMat.channel[1][i];
	}

    esselPrm1.inQueParams.prevLinkId       = esdupId3;
    esselPrm1.inQueParams.prevLinkQueId    = 1;
    esselPrm1.numOutQue                    = 2;
    esselPrm1.outQueParams[0].nextLink     = essclrId0;
    esselPrm1.outQueChInfo[0].outQueId     = 0;
    esselPrm1.outQueChInfo[0].numOutCh     = GetSCEncoderNum(pChannels);
    esselPrm1.outQueParams[1].nextLink     = esnullId0;
    esselPrm1.outQueChInfo[1].outQueId     = 1;
    esselPrm1.outQueChInfo[1].numOutCh     = GetChannelsNum(pChannels) - 1 - GetSCEncoderNum(pChannels);

    UInt8 gChScEnc		   = GetGlobeChannel(GetHCHANNELFromHENCODER(GetHANDLESCEnc(pChannels)));
    UInt8 gChannel		   = 0;
    UInt8 selSCEncChIdx    = 0;
    UInt8 selNonSCEncChIdx = 0;
    for (gChannel = 0; gChannel <= (GetChannelsNum(pChannels) - 1) - 1; gChannel ++)
    {
    	if (gChannel == gChScEnc)
      	{
    		esselPrm1.outQueChInfo[0].inChNum[selSCEncChIdx ++] = gChannel;
      	}
       	else
       	{
       		esselPrm1.outQueChInfo[1].inChNum[selNonSCEncChIdx ++] = gChannel;
       	}
    }

    essclrPrm0.inQueParams.prevLinkId		         =	esselId1;
    essclrPrm0.inQueParams.prevLinkQueId		     =	0;
    essclrPrm0.outQueParams.nextLink			     =	esmergeId2;
    essclrPrm0.pathId						         =	SCLR_LINK_SC5;
    essclrPrm0.scaleMode                            =  SCLR_SCALE_MODE_ABSOLUTE;
    essclrPrm0.outScaleFactor.absoluteResolution.outWidth	=	720;
    essclrPrm0.outScaleFactor.absoluteResolution.outHeight	=	576;
    essclrPrm0.inputFrameRate                     = GetChannelFrameRate(GetHCHANNELFromHENCODER(GetHANDLESCEnc(pChannels)));
    essclrPrm0.outputFrameRate                    = GetChannelFrameRate(GetHCHANNELFromHENCODER(GetHANDLESCEnc(pChannels)));
    essclrPrm0.tilerEnable                        = FALSE;
    essclrPrm0.enableLineSkipSc                   = FALSE;

    esmergePrm2.numInQue		=	2;
    esmergePrm2.inQueParams[0].prevLinkId		=	esselId0;
    esmergePrm2.inQueParams[0].prevLinkQueId	=	0;
    esmergePrm2.inQueParams[1].prevLinkId		=	essclrId0;
    esmergePrm2.inQueParams[1].prevLinkQueId	=	0;
    esmergePrm2.outQueParams.nextLink			=	esnsfId0;
    esmergePrm2.notifyNextLink	=	TRUE;

	esselPrm2.inQueParams.prevLinkId       = esdupId3;
	esselPrm2.inQueParams.prevLinkQueId    = 2;
	esselPrm2.numOutQue                    = 2;
	esselPrm2.outQueParams[0].nextLink     = esswMsId2;
	esselPrm2.outQueChInfo[0].outQueId     = 0;
	esselPrm2.outQueChInfo[0].numOutCh     = 1;
	esselPrm2.outQueParams[1].nextLink     = esnullId0;
	esselPrm2.outQueChInfo[1].outQueId     = 1;
	esselPrm2.outQueChInfo[1].numOutCh     = (GetChannelsNum(pChannels) - 1) - 1;

    gChannel		= 0;
    UInt8 selSDChIdx    = 0;
    UInt8 selNonSDChIdx = 0;
    for (gChannel = 0; gChannel <= (GetChannelsNum(pChannels) - 1) - 1; gChannel ++)
    {
    	if (gChannel == GetGlobeChannel(GetHCHANNELFromID(pChannels, GENERATE_ID(CHANNEL_CLS_SWMS, 0))))
      	{
    		esselPrm2.outQueChInfo[0].inChNum[selSDChIdx ++] = gChannel;
      	}
       	else
       	{
       		esselPrm2.outQueChInfo[1].inChNum[selNonSDChIdx ++] = gChannel;
       	}
    }

    esnullPrm0.numInQue					= 3;
    esnullPrm0.inQueParams[0].prevLinkId	= esselId0;
    esnullPrm0.inQueParams[0].prevLinkQueId= 1;
    esnullPrm0.inQueParams[1].prevLinkId	= esselId1;
    esnullPrm0.inQueParams[1].prevLinkQueId= 1;
    esnullPrm0.inQueParams[2].prevLinkId	= esselId2;
    esnullPrm0.inQueParams[2].prevLinkQueId= 1;

    pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_SWMS]->next->next->next;

    esswMsPrm2.numSwMsInst               = 1;
	esswMsPrm2.swMsInstId[0]             = SYSTEM_SW_MS_SC_INST_DEIHQ_SC_NO_DEI;

    esswMsPrm2.inQueParams.prevLinkId    = esselId2;
    esswMsPrm2.inQueParams.prevLinkQueId = 0;
    esswMsPrm2.outQueParams.nextLink     = esdisplayId2;
    esswMsPrm2.lineSkipMode              = FALSE;
    esswMsPrm2.enableLayoutGridDraw      = FALSE;
    esswMsPrm2.layoutPrm.outputFPS       = pHChannelNode->body.hChannel->entity.swms.frameRate;
    esswMsPrm2.maxInputQueLen            = SYSTEM_SW_MS_DEFAULT_INPUT_QUE_LEN;
    esswMsPrm2.maxOutRes                 = pHChannelNode->body.hChannel->entity.swms.std;
    esswMsPrm2.numOutBuf                 = 0;
  	SwMsSetLayoutParams(esswMsId2, SWMS_LAYOUT_PATTERN_1, &esswMsPrm2);

    esdisplayPrm2.numInputQueues                = 1;
    esdisplayPrm2.activeQueue                   = 0;
    esdisplayPrm2.inQueParams[0].prevLinkId     = esswMsId2;
    esdisplayPrm2.inQueParams[0].prevLinkQueId  = 0;
    esdisplayPrm2.displayRes                    = pHChannelNode->body.hChannel->entity.swms.std;
    esdisplayPrm2.forceFieldSeparatedInputMode  = FALSE;

    esnsfPrm0.inQueParams.prevLinkId           = esmergeId2;
    esnsfPrm0.inQueParams.prevLinkQueId        = 0;
    esnsfPrm0.outQueParams[0].nextLink         = esipcOutVpssId0;
    esnsfPrm0.bypassNsf                        = TRUE;
    esnsfPrm0.tilerEnable                      = TRUE;
    esnsfPrm0.numOutQue                        = 1;
    esnsfPrm0.numBufsPerCh                     = 0;

    esipcOutVpssPrm0.inQueParams.prevLinkId    = esnsfId0;
    esipcOutVpssPrm0.inQueParams.prevLinkQueId = 0;
    esipcOutVpssPrm0.numOutQue                 = 1;
    esipcOutVpssPrm0.numChPerOutQue[0]         = 1;
    esipcOutVpssPrm0.outQueParams[0].nextLink  = esipcInVideoId0;
    esipcOutVpssPrm0.notifyNextLink            = TRUE;
    esipcOutVpssPrm0.notifyPrevLink            = FALSE;
    esipcOutVpssPrm0.noNotifyMode              = FALSE;
    esipcOutVpssPrm0.numChPerOutQue[0]         = 0;
    esipcOutVpssPrm0.equallyDivideChAcrossOutQues = FALSE;

    esipcInVideoPrm0.inQueParams.prevLinkId    = esipcOutVpssId0;
    esipcInVideoPrm0.inQueParams.prevLinkQueId = 0;
    esipcInVideoPrm0.numOutQue                 = 1;
    esipcInVideoPrm0.numChPerOutQue[0]         = 1;
    esipcInVideoPrm0.outQueParams[0].nextLink  = esencId0;
    esipcInVideoPrm0.notifyNextLink            = TRUE;
    esipcInVideoPrm0.notifyPrevLink            = FALSE;
    esipcInVideoPrm0.noNotifyMode              = FALSE;
    esipcInVideoPrm0.numChPerOutQue[0]         = 0;
    esipcInVideoPrm0.equallyDivideChAcrossOutQues = FALSE;

    for (pHEncoderNode = pChannels->encoderList->next, i = 0; pHEncoderNode; pHEncoderNode = pHEncoderNode->next, i ++)
    {
    	HCHANNEL hChannel = GetHCHANNELFromHENCODER(pHEncoderNode->body.hEncoder);

    	esencPrm0.chCreateParams[i].format                             = pHEncoderNode->body.hEncoder->format;
    	esencPrm0.chCreateParams[i].profile                            = pHEncoderNode->body.hEncoder->profile;
        esencPrm0.chCreateParams[i].dataLayout                         = IVIDEO_FIELD_SEPARATED;
        esencPrm0.chCreateParams[i].fieldMergeEncodeEnable             = FALSE;
        esencPrm0.chCreateParams[i].enableAnalyticinfo                 = FALSE;
        esencPrm0.chCreateParams[i].enableWaterMarking                 = FALSE;
        esencPrm0.chCreateParams[i].encodingPreset                     = XDM_USER_DEFINED;
        esencPrm0.chCreateParams[i].rateControlPreset                  = IVIDEO_USER_DEFINED;
        esencPrm0.chCreateParams[i].enableHighSpeed                    = FALSE;
        esencPrm0.chCreateParams[i].defaultDynamicParams.interFrameInterval  = 1;
        esencPrm0.chCreateParams[i].defaultDynamicParams.intraFrameInterval  = pHEncoderNode->body.hEncoder->intraFrameInterval;
        esencPrm0.chCreateParams[i].defaultDynamicParams.inputFrameRate      = GetChannelFrameRate(hChannel);
        esencPrm0.chCreateParams[i].defaultDynamicParams.targetBitRate       = pHEncoderNode->body.hEncoder->targetBitRate;
        esencPrm0.chCreateParams[i].defaultDynamicParams.mvAccuracy          = IVIDENC2_MOTIONVECTOR_QUARTERPEL;
        esencPrm0.chCreateParams[i].defaultDynamicParams.rcAlg               = pHEncoderNode->body.hEncoder->rcAlg;
        esencPrm0.chCreateParams[i].defaultDynamicParams.qpMin               = 0;
        esencPrm0.chCreateParams[i].defaultDynamicParams.qpMax               = 51;
        esencPrm0.chCreateParams[i].defaultDynamicParams.qpInit              = -1;
        esencPrm0.chCreateParams[i].defaultDynamicParams.vbrDuration         = 8;
        esencPrm0.chCreateParams[i].defaultDynamicParams.vbrSensitivity      = 0;
    }
    esencPrm0.inQueParams.prevLinkId   = esipcInVideoId0;
    esencPrm0.inQueParams.prevLinkQueId= 0;
    esencPrm0.outQueParams.nextLink    = esipcBitsOutVideoId0;
    esencPrm0.numBufPerCh[0]           = 0;

    esipcBitsOutVideoPrm0.baseCreateParams.inQueParams.prevLinkId      = esencId0;
    esipcBitsOutVideoPrm0.baseCreateParams.inQueParams.prevLinkQueId   = 0;
    esipcBitsOutVideoPrm0.baseCreateParams.numOutQue                   = 1;
    esipcBitsOutVideoPrm0.baseCreateParams.numChPerOutQue[0]           = 1;
    esipcBitsOutVideoPrm0.baseCreateParams.outQueParams[0].nextLink    = esipcBitsInHostId0;
    esipcBitsOutVideoPrm0.baseCreateParams.notifyNextLink              = FALSE;
    esipcBitsOutVideoPrm0.baseCreateParams.notifyPrevLink              = FALSE;
    esipcBitsOutVideoPrm0.baseCreateParams.noNotifyMode                = TRUE;
    IPCBitsOutRTOS_Params_Init(&esipcBitsOutVideoPrm0);

    esipcBitsInHostPrm0.baseCreateParams.inQueParams.prevLinkId        = esipcBitsOutVideoId0;
    esipcBitsInHostPrm0.baseCreateParams.inQueParams.prevLinkQueId     = 0;
    esipcBitsInHostPrm0.baseCreateParams.numOutQue                     = 1;
    esipcBitsInHostPrm0.baseCreateParams.numChPerOutQue[0]             = 1;
    esipcBitsInHostPrm0.baseCreateParams.notifyNextLink                = FALSE;
    esipcBitsInHostPrm0.baseCreateParams.notifyPrevLink                = FALSE;
    esipcBitsInHostPrm0.baseCreateParams.noNotifyMode                  = TRUE;
    IPCBitsInHLOS_Params_Init(&esipcBitsInHostPrm0);

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    System_linkCreate(esipcBitsOutHostId0,&esipcBitsOutHostPrm0,sizeof(esipcBitsOutHostPrm0));
    System_linkCreate(esipcBitsInVideoId0,&esipcBitsInVideoPrm0,sizeof(esipcBitsInVideoPrm0));
    System_linkCreate(esdecId0, &esdecPrm0, sizeof(esdecPrm0));
    System_linkCreate(esipcOutVideoId0, &esipcOutVideoPrm0, sizeof(esipcOutVideoPrm0));
    System_linkCreate(esipcInVpssId0, &esipcInVpssPrm0, sizeof(esipcInVpssPrm0));
    System_linkCreate(esipcFramesInVpssId0, &esipcFramesInVpssPrm0, sizeof(esipcFramesInVpssPrm0));
    System_linkCreate(esmergeId0, &esmergePrm0, sizeof(esmergePrm0));

    System_linkCreate(esipcFramesOutVpssId0, &esipcFramesOutVpssPrm0, sizeof(esipcFramesOutVpssPrm0));
    System_linkCreate(esipcFramesInDspId0, &esipcFramesInDspPrm0, sizeof(esipcFramesInDspPrm0));
    System_linkCreate(esosdId0, &esosdPrm0, sizeof(esosdPrm0));

    System_linkCreate(esdupId2, &esdupPrm2, sizeof(esdupPrm2));
    for (i=0; i<2; i++)
    {
        System_linkCreate(esswMsId[i], &esswMsPrm[i], sizeof(esswMsPrm[i]));
        if (0 == i)
        {
            System_linkCreate(esipcFramesOutVpssId1, &esipcFramesOutVpssPrm1, sizeof(esipcFramesOutVpssPrm1));
            System_linkCreate(esipcFramesInDspId1, &esipcFramesInDspPrm1, sizeof(esipcFramesInDspPrm1));
            System_linkCreate(esosdId1, &esosdPrm1, sizeof(esosdPrm1));
        }
        System_linkCreate(esdupId[i], &esdupPrm[i], sizeof(esdupPrm[i]));
        System_linkCreate(esdisplayId[i], &esdisplayPrm[i], sizeof(esdisplayPrm[i]));
    }


    System_linkCreate(esmergeId1, &esmergePrm1, sizeof(esmergePrm1));
    System_linkCreate(esdupId3, &esdupPrm3, sizeof(esdupPrm3));
    System_linkCreate(esselId0, &esselPrm0, sizeof(esselPrm0));
    System_linkCreate(esselId1, &esselPrm1, sizeof(esselPrm1));
    System_linkCreate(essclrId0, &essclrPrm0, sizeof(essclrPrm0));
    System_linkCreate(esmergeId2, &esmergePrm2, sizeof(esmergePrm2));
    System_linkCreate(esselId2, &esselPrm2, sizeof(esselPrm2));
    System_linkCreate(esnullId0, &esnullPrm0, sizeof(esnullPrm0));
    System_linkCreate(esswMsId2, &esswMsPrm2, sizeof(esswMsPrm2));
    System_linkCreate(esdisplayId2, &esdisplayPrm2, sizeof(esdisplayPrm2));
    System_linkCreate(esnsfId0, &esnsfPrm0, sizeof(esnsfPrm0));
    System_linkCreate(esipcOutVpssId0, &esipcOutVpssPrm0, sizeof(esipcOutVpssPrm0));
    System_linkCreate(esipcInVideoId0, &esipcInVideoPrm0, sizeof(esipcInVideoPrm0));
    System_linkCreate(esencId0, &esencPrm0, sizeof(esencPrm0));
    System_linkCreate(esipcBitsOutVideoId0, &esipcBitsOutVideoPrm0, sizeof(esipcBitsOutVideoPrm0));
    System_linkCreate(esipcBitsInHostId0, &esipcBitsInHostPrm0, sizeof(esipcBitsInHostPrm0));//*/

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    Chains_memPrintHeapStatus();

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    {
        System_linkStart(esencId0);
        System_linkStart(esnsfId0);
        System_linkStart(esdisplayId2);
        System_linkStart(esswMsId2);
        System_linkStart(esmergeId2);
        System_linkStart(essclrId0);
        System_linkStart(esnullId0);
        System_linkStart(esselId2);
        System_linkStart(esselId1);
        System_linkStart(esselId0);
        System_linkStart(esdupId3);
        System_linkStart(esmergeId1);
        for (i=0; i<2; i++)
        {
            System_linkStart(esdisplayId[i]);
            System_linkStart(esdupId[i]);
            if (0 == i)
            {
                System_linkStart(esipcFramesOutVpssId1);
                System_linkStart(esipcFramesInDspId1);
                System_linkStart(esosdId1);
            }
            System_linkStart(esswMsId[i]);
        }
        System_linkStart(esdupId2);

        System_linkStart(esipcFramesOutVpssId0);
        System_linkStart(esipcFramesInDspId0);
        System_linkStart(esosdId0);

        System_linkStart(esmergeId0);
        System_linkStart(esipcFramesInVpssId0);
        System_linkStart(esipcFramesOutHostId0);
        System_linkStart(escaptureId);
        System_linkStart(esipcInVpssId0);
        System_linkStart(esipcOutVideoId0);
        System_linkStart(esdecId0);
        System_linkStart(esipcBitsInVideoId0);
        System_linkStart(esipcBitsOutHostId0);

        startAudioCaptEnc(pChannels);

        Chain_Stat();

        //////////////////////////////////////////////////////////////////////////////////////////////////////

        while(1)
        {
            ch = Chains_menuRunTime();
            if (ch=='0')
                break;
            if(ch == 'd')
            {
                System_linkControl( SYSTEM_LINK_ID_VENC_0,
                                    ENC_LINK_CMD_PRINT_IVAHD_STATISTICS,
                                    NULL, 0, TRUE);
            }
            if (ch=='l')
            {
            	UInt32 dispid = Chains_menuSelectDisplayNumber();
            	UInt32 swmslayoutid = Chains_menuSelectSwMsLayoutId();

            	SwMsSetLayout(esswMsId[dispid], swmslayoutid, &esswMsPrm[dispid]);
            }
            if (ch=='c')
            {
            	UInt32 dispid = Chains_menuSelectDisplayNumber();
            	UInt32 winid  = Chains_getIntValue("Window Id : ", 0, 255, 0);
            	UInt32 chId   = Chains_getIntValue("Channel Id : ", 0, 255, 0);

            	switch (SwMsMapChtoWin(esswMsId[dispid], winid, chId, &esswMsPrm[dispid]))
            	{
            	case ERR_CHNUM_INVALID:
            		printf("\n Invalid channel ID!!! \n");
            		break;
            	case ERR_CHNUM_INVISIBLE:
            		printf("\n Channel cannot be visible!!! \n");
            		break;
            	case ERR_WINNUM_INVALID:
            		printf("\n Invalid Window ID!!! \n");
            		break;
            	case SUCCEED:
            		break;
            	default:
            		break;
            	}
            }
            if (ch=='x')
            {
            	UInt32 dispid = Chains_menuSelectDisplayNumber();
            	UInt32 winid1 = Chains_getIntValue("Window Id 1 : ", 0, 255, 0);
            	UInt32 winid2 = Chains_getIntValue("Window Id 2 : ", 0, 255, 0);

            	switch (SwMsExchangeWin(esswMsId[dispid], winid1, winid2, &esswMsPrm[dispid]))
            	{
            	case ERR_WINNUM_SAME:
            		printf("\n Window to be exchanged are same!!! \n");
            		break;
            	case ERR_WINNUM_INVALID:
            		printf("\n Invalid window ID!!! \n");
            		break;
            	case ERR_WINNUM_BLANK:
            		printf("\n Blank window!!! \n");
            		break;
            	default:
            		break;
            	}
            }
            if (ch=='s')
            {
            	UInt32 channel = Chains_getIntValue("channel Id : ", 0, 255, 0);
            	UInt32 enable = Chains_getIntValue("On/Off (1/0) : ", 0, 1, 1);

            	switch (SwMsSwitchChannel(channel, enable, swMsPrmList))
            	{
            	case ERR_CHNUM_INVALID:
            		printf("\n channel to be on/off is invalid!!! \n");
            		break;
            	default:
            		break;
            	}
            }
            if (ch == 'm')
            {
            	chId   = 0;
            	winId  = Chains_getIntValue("Window Id : ", 0, CHAINS_OSD_NUM_WINDOWS-1, 0);

            	swmsFont = font2;
                printf("\nInput OSD Window Position:\n");
                swmsFont.winposition.StartX   = Chains_getIntValue("StartX : ", 0,1280, 96);
                swmsFont.winposition.StartY   = Chains_getIntValue("StartY : ", 0,720, 96);
                printf("\nInput character display in osd:\n");
                fflush(stdin);
                scanf("%s",&test);

            	UInt32 fontcolor = Chains_menuSelectOSDFontColor();
            	UInt32 fontcsize = Chains_menuSelectOSDFontSize();

            	swmsFont.fontcolor = fontcolor;
            	swmsFont.fontsize  = fontcsize;

            	AlgLink_OsdChWinParams *chWinPrm  = &esosdPrm1.osdChCreateParams[chId].chDefaultParams;

                chWinPrm->chId                             = chId;
                chWinPrm->colorKey[0]                      = 0x60;
                chWinPrm->colorKey[1]                      = 0x60;
                chWinPrm->colorKey[2]                      = 0x60;
                chWinPrm->winPrm[winId].format             = SYSTEM_DF_YUV422I_YUYV;
                chWinPrm->winPrm[winId].globalAlpha        = CHAINS_OSD_GLOBAL_ALPHA;
                chWinPrm->winPrm[winId].transperencyEnable = CHAINS_OSD_TRANSPARENCY;
                chWinPrm->winPrm[winId].enableWin          = CHAINS_OSD_ENABLE_WIN;
                osdDrawText(test,swmsFont,(char*)osdWinBuPtr1[chId][winId],
                		&chWinPrm->winPrm[winId],FALSE);
                System_linkControl(esosdId1, ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM,
    		                   chWinPrm, sizeof(AlgLink_OsdChWinParams), TRUE);
            }
            if (ch == 'e')
            {
            	winId  = Chains_getIntValue("Window Id: ", 0, 1, 0);
            	AlgLink_OsdChWinParams *chWinPrm  =
            			           &esosdPrm1.osdChCreateParams[0].chDefaultParams;
                chWinPrm->winPrm[winId].globalAlpha            = FALSE;
                System_linkControl(esosdId1, ALG_LINK_OSD_CMD_SET_CHANNEL_WIN_PRM,
     		                  chWinPrm, sizeof(AlgLink_OsdChWinParams), TRUE);
            }
            if (ch == 'p')
            {
                System_linkControl(escaptureId, CAPTURE_LINK_CMD_PRINT_ADV_STATISTICS, NULL, 0, TRUE);
                usleep(500000);
            }
        }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

        PeripheralProcessEncodedDataStop();
        sleep(1);

        PeripheralGetStreamsStop();
        PutFullOutStop(&ipc_ctrl);
        GetEmptyOutStop(&ipc_ctrl);

        uart_communicate_stop();

        uart_volum_stop();

        System_linkStop(escaptureId);
        System_linkStop(esipcBitsOutHostId0);
        System_linkStop(esipcBitsInVideoId0);
        System_linkStop(esdecId0);
        System_linkStop(esipcOutVideoId0);
        System_linkStop(esipcInVpssId0);
        System_linkStop(esipcFramesOutHostId0);
        System_linkStop(esipcFramesInVpssId0);
        System_linkStop(esmergeId0);

    	System_linkStop(esipcFramesOutVpssId0);
    	System_linkStop(esipcFramesInDspId0);
    	System_linkStop(esosdId0);

        System_linkStop(esdupId2);
        for (i=0; i<2; i++)
        {
            System_linkStop(esswMsId[i]);
            if (0 == i)
            {
            	System_linkStop(esipcFramesOutVpssId1);
            	System_linkStop(esipcFramesInDspId1);
            	System_linkStop(esosdId1);
            }
            System_linkStop(esdupId[i]);
            System_linkStop(esdisplayId[i]);
        }
        System_linkStop(esmergeId1);
        System_linkStop(esdupId3);
        System_linkStop(esselId0);
        System_linkStop(esselId1);
        System_linkStop(esselId2);
        System_linkStop(essclrId0);
        System_linkStop(esmergeId2);
        System_linkStop(esnullId0);
        System_linkStop(esswMsId2);
        System_linkStop(esdisplayId2);
        System_linkStop(esnsfId0);
        System_linkStop(esencId0);
        System_linkStop(esipcBitsOutVideoId0);
        System_linkStop(esipcBitsInHostId0);
    }

    //////////////////////////////////////////////////////////////////////////////////////////////////////

    System_linkDelete(escaptureId);
    System_linkDelete(esipcBitsOutHostId0);
    System_linkDelete(esipcBitsInVideoId0);
    System_linkDelete(esdecId0);
    System_linkDelete(esipcOutVideoId0);
    System_linkDelete(esipcInVpssId0);
    System_linkDelete(esipcFramesOutHostId0);
    System_linkDelete(esipcFramesInVpssId0);
    System_linkDelete(esmergeId0);

	System_linkDelete(esipcFramesOutVpssId0);
	System_linkDelete(esipcFramesInDspId0);
	System_linkDelete(esosdId0);

    System_linkDelete(esdupId2);
    for (i=0; i<2; i++)
    {
        System_linkDelete(esswMsId[i]);
        if (0 == i)
        {
        	System_linkDelete(esipcFramesOutVpssId1);
        	System_linkDelete(esipcFramesInDspId1);
        	System_linkDelete(esosdId1);
        }
        System_linkDelete(esdupId[i]);
        System_linkDelete(esdisplayId[i]);
    }
    System_linkDelete(esmergeId1);
    System_linkDelete(esdupId3);
    System_linkDelete(esselId0);
    System_linkDelete(esselId1);
    System_linkDelete(esselId2);
    System_linkDelete(essclrId0);
    System_linkDelete(esmergeId2);
    System_linkDelete(esnullId0);
    System_linkDelete(esswMsId2);
    System_linkDelete(esdisplayId2);
    System_linkDelete(esnsfId0);
    System_linkDelete(esipcOutVpssId0);
    System_linkDelete(esipcInVideoId0);
    System_linkDelete(esencId0);
    System_linkDelete(esipcBitsOutVideoId0);
    System_linkDelete(esipcBitsInHostId0);

    Chains_displayCtrlDeInit();
}

    I implemented Vsys_printDetailedStatistics and Vsys_printBufferStatistics by myself.

    Log from start up:

    1212.log_startup_201311061416.txt

    LINK statistics and buffer info ( 3 times with 1 min interval ):

    4237.info_LINK_stat_buff_201311061416.txt

    It seemed that IpcOutM3LINK ( SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0 ) can not get frames from its previous LINK ( NSF LINK )...

    Thanks a lot!

  • 0 in reply to Ri-Ping YU
    TI__Guru 59700 points

    Your chains code is wrong .Pls correct the following:

       esipcOutVpssPrm0.notifyPrevLink            = FALSE; ---SHOULD BE TRUE

       esipcInVideoPrm0.notifyPrevLink            = FALSE; -- SHOULD BE TRUE

     

    Also you are setting wrong value for

    esipcBitsOutHostPrm0.totalBitStreamBufferSize[i] = 8;

     

    Refer the mcfw usecases for correct setting of this parameter.

  • 0 in reply to Badri Narayanan
    Expert 1460 points

    Now, esipcOutVpssId0, esipcInVideoId0, can work properly, judged through LINK statistic information, while encode LINK still can not work normally, it seemed the 3rd (indexed from 0) encoding channel has skipped all frame sending to it;

    1031.info_LINK_stat_buff_201311081814.txt

    And when I connect rtsp streams using VLC client, encountered issue as :

    Segmentation fault
     [m3video]  68311: NOTIFY: Send Event to [HOST][26] failed !!! (status = -14)
     [m3video]  68311: Assertion @ Line: 69 in links_common/system/system_ipc_notify.c: status == Notify_S_SUCCESS : failed !!!

    after that, programe exits.

    How to fix it?

    Thanks a lot!

  • 0 in reply to Ri-Ping YU
    TI__Guru 59700 points

    Have you fixed esipcBitsOutHostPrm0.totalBitStreamBufferSize[i] = 8; setting like I mentioned ? By VLC stream does it mean decode chain is started ?

  • 0 in reply to Badri Narayanan
    Expert 1460 points

    I have not fixed esipcBitsOutHostPrm0.totalBitStreamBufferSize[i] = 8, because this parameter is belonging to decode part of my chain, but I want to make encode part of the chain work properly at first.

    I mean that the H264 streams produced by Enc LINK be transmitted to A8 through ipcBits LINKs, after that, those streams will be send to network, a client like VLC can connect and view the streams.

    But now, ipcOutVpss and ipcInVideo can work normally according to your suggestion, while Enc LINK can still not work properly.

    expect your further suggestion

    Thanks a lot!

  • 0 in reply to Ri-Ping YU
    TI__Guru 59700 points

    Segfault indicate issue with invalid memory access on A8. You require debug on your application side to determine cause of SegFault by getting backtrace from the core dump.