• State Resolved
  • Locked Locked
  • Replies 5 replies
  • Subscribers 99 subscribers
  • Views 524 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.

NSF LINK leads to dropping frame

Ri-Ping YU
Expert 1460 points

Hello everyone

My usecase:

Chains-0

(video capture, OSD, Swms and Display) --> Merge2-->NSF0 -->IpcOutVpss0 --> IpcInVideo0 --> Enc --> IpcBitsOutVideo0 --> IpcBitsInHost0

6 channels for encoding.

I encountered one problem, frame dropping...

All my video sources' framerate is 30fps, but NSF0 and Enc process approximately 21fps;

I think this is because the capability of NSF LINK, so I appended 1 NSF(NSF-1), my usecase for test:

Chains-1

(video capture, OSD, Swms and Display) --> Merge2 --> ISelect3 ---+--->NSF0 ---+--->Merge --> Null1

                                                                                                                          |--->NSF1----|

NSF0 process channel 0,1,2, NSF1 for channel 3,4,5; Frame dropping still exists, as formmer; Even I used all 4 NSF LINK, frame dropping still exists.

Following is the log of LINK stat and buffer infomation

6403.LINK_Stat_Buf_6Enc_2NSF_drop.txt

While when I use Chains-0, 4 channels for encoding, one NSF, there is no frame dropping.

Furthur, I modified my usecase as following:

Chains-2

(video capture, OSD, Swms and Display) --> Merge2 --> Null1

6 channels for encoding, this time, there is no frame dropping, chain work properly

I conclude that frame droppingis resulting from the lack of capability of NSF LINK, but In Chain-1, adopting 2 NSF LINKs, the capability seemed still as working with one NSF LINK.

I want to know how can I solve this problem?

Thanks in advance for any reply!

  • 0
    TI__Guru 59700 points

    Answered here: http://e2e.ti.com/support/dsp/davinci_digital_media_processors/f/717/t/283475/reply.aspx

    Note that there is a single NSF h/w block and so adding multiple instances of NSF will not help improve performance

  • 0 in reply to Badri Narayanan
    Expert 1460 points

    Hi Badri, Thanks for your reply!

    I have modified my usecase as this:

    (video capture, OSD, Swms and Display) --> Merge2-->Select3--+-->NSF0-+-->Merge4 -->IpcOutVpss0 --> IpcInVideo0 --> Enc --> IpcBitsOutVideo0 --> IpcBitsInHost0

                                                                                                                        |--------------|

    and I changed Capture output format from  "SYSTEM_DF_YUV422I_YUYV" to "SYSTEM_DF_YUV420SP_UV", which can be sent to Encode LINK directly without NSF LINK.

    Under this condition, NSF LINK just served for 2 swms link outputs with YUV422 format. The issue dropping frame has been solved.

    But encountered one new problem.messages as following:

     [m3vpss ]  4957948: CAPTURE: Overflow detected on VIP1, Total Resets = 2119
     [m3vpss ]  4958636: CAPTURE: Overflow detected on VIP1, Total Resets = 2120
     [m3vpss ]  4959292: CAPTURE: Overflow detected on VIP0, Total Resets = 2121
     [m3vpss ]  4961612: CAPTURE: Overflow detected on VIP1, Total Resets = 2122

    Infinitely...1 time per 2-3 seconds approximately...

    When this occurs, picture of camera connected to VIP0-1 and VIP1-1 flicked(the other two camera behaved normally), as shown in the video, Pls pay more attention

    to the police car...

    By the way, this didn't happen when the capture output format is set to SYSTEM_DF_YUV422I_YUYV.

    How can I fix this issue?

    Thanks in advance for any reply!

    Resume my codes for setting capture LINK

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

        for (pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_CAMERA]->next, i = 0;
                pHChannelNode && (i < GetCameraNum(pChannels));
                pHChannelNode = pHChannelNode->next, i ++)
        {
            //vipInstId = SYSTEM_CAPTURE_INST_VIP0_PORTA + 2 * i;
            esvipInstId = SYSTEM_CAPTURE_INST_VIP0_PORTA + i;
            espCaptureInstPrm                     = &escapturePrm.vipInst[i];
            espCaptureInstPrm->vipInstId          = esvipInstId % SYSTEM_CAPTURE_INST_MAX;
            //pCaptureInstPrm->videoDecoderId     = SYSTEM_DEVICE_VID_DEC_SII9233A_DRV;
            espCaptureInstPrm->videoDecoderId     = 0;
            espCaptureInstPrm->inDataFormat       = SYSTEM_DF_YUV422P;
            espCaptureInstPrm->standard           = pHChannelNode->body.hChannel->entity.camera.std;
            espCaptureInstPrm->numOutput          = 1;
            espCaptureInstPrm->numChPerOutput     = 1;
            espCaptureInstPrm->frameCaptureMode   = FALSE;
            espCaptureInstPrm->fieldsMerged       = FALSE;

            espCaptureOutPrm                      = &espCaptureInstPrm->outParams[0];
            espCaptureOutPrm->dataFormat          = SYSTEM_DF_YUV420SP_UV;//SYSTEM_DF_YUV422I_YUYV;
            espCaptureOutPrm->scEnable            = FALSE;
            espCaptureOutPrm->outQueId            = 0;
        }
        escapturePrm.outQueParams[0].nextLink     = esmergeId0;

    my LINK Stat and buffer infomation

    1462.LINK_Stat_Buf_Info_6Enc_Cam420_Capoverflow.txt

  • 0 in reply to Ri-Ping YU
    Expert 1460 points

    Hi, everybody

    My further test about Capture overflow:

    1) (Capture, Swms) ----> IpcoutVpss ----> IpcInVideo ----> Enc ----> IpcBitsOutRTOS ----> IpcBitsInHLOS

         I can see the issue: Capture overflow;

    2) (Capture, Swms) ----> Null

        The issue didn't appear any more;

    My Chain Setting (pay more attention to Line 557-588 for capture LINK and Line 956-1046 for IpcOutVpss, IpcInVideo, Enc, IpcBitsOutRTOS, IpcBitsInHLOS LINK):

    Fullscreen 3823.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/chains_common.h>
#include <demos/link_api_demos/common/Channels.h>
#include <demos/link_api_demos/common/swms.h>
#include <demos/link_api_demos/common/log.h>
#include <demos/link_api_demos/common/ipcBits.h>
#include <demos/link_api_demos/common/chains_ipcFrames.h>
#include <demos/link_api_demos/interface/ControllingInterface.h>
#include <demos/link_api_demos/interface/set_osd.h>
#include <demos/link_api_demos/common/esvoiceStimulate.h>
#include <demos/link_api_demos/vpss_chains/demo_text.h>
#include <mcfw/interfaces/link_api/system_common.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
      	    };
  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  = 2,
          .EncChList = {4, 5},
          .DecNumCh  = 0,
          .DecChList = {0},
      },
      .ivaMap[1] =
      {
          .EncNumCh  = 2,
          .EncChList = {0, 2},
          .DecNumCh  = 0,
          .DecChList = {0},
      },
      .ivaMap[2] =
      {
          .EncNumCh  = 2,
          .EncChList = {1, 3},
          .DecNumCh  = 0,
          .DecChList = {0},
      },
  };//*/
/*
  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;

SelectLink_CreateParams				esselPrm3;
NsfLink_CreateParams        		esnsfPrm0;
MergeLink_CreateParams    		  	esmergePrm4;

//NullLink_CreateParams				esnullPrm1;

IpcLink_CreateParams                esipcOutVpssPrm0;
IpcLink_CreateParams                esipcInVideoPrm0;

//NullLink_CreateParams				esvideonullPrm0;

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 esselId3;
UInt32 esnsfId0;
UInt32 esmergeId4;

//UInt32 esnullId1;

UInt32 esipcOutVpssId0;
UInt32 esipcInVideoId0;

//UInt32 esvideonullId0;

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 ;
    for(chId = 0; chId < 1 ;chId ++)
    {
        switch(signo)
        {
            case SIGALRM:
                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 (voiceStimulateThr.hndl)
                {
                	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();

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

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

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

    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(SelectLink_CreateParams,esselPrm3);
    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;

    esselId3                = SYSTEM_VPSS_LINK_ID_SELECT_3;
    esnsfId0         		= SYSTEM_LINK_ID_NSF_0;
    esmergeId4	  		    = SYSTEM_VPSS_LINK_ID_MERGE_4;

//    esnullId1				= SYSTEM_VPSS_LINK_ID_NULL_1;

    esipcOutVpssId0  		= SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0;
    esipcInVideoId0  		= SYSTEM_VIDEO_LINK_ID_IPC_IN_M3_0;

//    esvideonullId0			= SYSTEM_VIDEO_LINK_ID_NULL_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);
//    SwMsLayoutInit();

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

    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;
    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.inQueParams.prevLinkId    = esipcBitsInVideoId0;
    esdecPrm0.inQueParams.prevLinkQueId = 0;
    esdecPrm0.outQueParams.nextLink     = esipcOutVideoId0;
    esdecPrm0.tilerEnable               = TRUE;

    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.inputFrameRate                 = 30;	////****~~~~
    esipcFramesOutHostPrm0.baseCreateParams.outputFrameRate                = 30;	////****~~~~
    //esipcFramesOutHostPrm0.baseCreateParams.notifyNextLink                 = FALSE;//TRUE;//suggested by Badri on 20130611
    esipcFramesOutHostPrm0.baseCreateParams.notifyNextLink                 = TRUE;
    esipcFramesOutHostPrm0.baseCreateParams.notifyPrevLink                 = FALSE;
    esipcFramesOutHostPrm0.baseCreateParams.notifyProcessLink              = FALSE;
    //esipcFramesOutHostPrm0.baseCreateParams.noNotifyMode                   = TRUE;//FALSE;//suggested by Badri on 20130611
    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].bufferFmt                   = 1;//0;
    esipcFramesOutHostPrm0.inQueInfo.chInfo[0].codingformat                = IVIDEO_H264HP;//0;
    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_SF_INTERLACED;//     kijjr jm    2
    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.inputFrameRate              = 30;
    //esipcFramesInVpssPrm0.baseCreateParams.noNotifyMode                = TRUE;//FALSE;//suggested by Badri on 20130611
    esipcFramesInVpssPrm0.baseCreateParams.noNotifyMode                = FALSE;
    esipcFramesInVpssPrm0.baseCreateParams.notifyNextLink              = TRUE;
    //esipcFramesInVpssPrm0.baseCreateParams.notifyPrevLink              = FALSE;//TRUE;//suggested by Badri on 20130611
    esipcFramesInVpssPrm0.baseCreateParams.notifyPrevLink              = TRUE;
    esipcFramesInVpssPrm0.baseCreateParams.numOutQue                   = 1;
    esipcFramesInVpssPrm0.baseCreateParams.numChPerOutQue[0]           = 1;
    esipcFramesInVpssPrm0.baseCreateParams.outQueParams[0].nextLink    = esmergeId0;
    //esipcFramesInVpssPrm0.baseCreateParams.outputFrameRate             = 60;
    esipcFramesInVpssPrm0.baseCreateParams.outputFrameRate             = 30;

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

    for (pHChannelNode = pChannels->hChannelList[CHANNEL_CLS_CAMERA]->next, i = 0;
    		pHChannelNode && (i < GetCameraNum(pChannels));
    		pHChannelNode = pHChannelNode->next, i ++)
    {
        //vipInstId = SYSTEM_CAPTURE_INST_VIP0_PORTA + 2 * i;
    	esvipInstId = SYSTEM_CAPTURE_INST_VIP0_PORTA + i;
        espCaptureInstPrm                     = &escapturePrm.vipInst[i];
        espCaptureInstPrm->vipInstId          = esvipInstId % SYSTEM_CAPTURE_INST_MAX;
        //pCaptureInstPrm->videoDecoderId     = SYSTEM_DEVICE_VID_DEC_SII9233A_DRV;
        espCaptureInstPrm->videoDecoderId     = 0;
        espCaptureInstPrm->inDataFormat       = SYSTEM_DF_YUV422P;
        espCaptureInstPrm->standard           = pHChannelNode->body.hChannel->entity.camera.std;
        espCaptureInstPrm->numOutput          = 1;
        espCaptureInstPrm->numChPerOutput     = 1;
        espCaptureInstPrm->frameCaptureMode   = FALSE;
        espCaptureInstPrm->fieldsMerged       = FALSE;

        espCaptureOutPrm                      = &espCaptureInstPrm->outParams[0];
        espCaptureOutPrm->dataFormat          = SYSTEM_DF_YUV420SP_UV;//SYSTEM_DF_YUV422I_YUYV;
        espCaptureOutPrm->scEnable            = FALSE;
        espCaptureOutPrm->outQueId            = 0;
    }
    escapturePrm.outQueParams[0].nextLink     = esmergeId0;

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

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

    printf("00000000000000000000000000000000000000000000000000000000000000000000000000000\n");

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

    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;

    printf("1111111111111111111111111111111111111111111111111111111111111111111111111111111\n");

    ///////////////////////////////////////////////////  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;

    printf("22222222222222222222222222222222222222222222222222222222222222222222222222222\n");

    //////////////////////////////////////////////////  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;

        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;

        printf("33333333333333333333333333333333333333333333333333333333333333333333333\n");
        //////////////////////////////////////////////////  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;

        printf("66666666666666666666666666666666666666666666666666666666666666666666666666\n");

        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;

        printf("77777777777777777777777777777777777777777777777777777777777777777777777777777\n");

        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                    = 4;
            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;
                	printf("444444444444444444444444444444444444444444444444444444444444444\n");
                	osdDrawText("1999/12/23 00:00:00",font,(char*)osdWinBuPtr1[chId][winId],&chWinPrm1->winPrm[winId],FALSE);
                	printf("555555555555555555555555555555555555555555555555555555555555555\n");
                }
            }
        }

        {
            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			=	esselId3;
    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;

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

	esselPrm3.inQueParams.prevLinkId       = esmergeId2;
	esselPrm3.inQueParams.prevLinkQueId    = 0;
	esselPrm3.numOutQue                    = 2;
	esselPrm3.outQueParams[0].nextLink     = esmergeId4;
	esselPrm3.outQueChInfo[0].outQueId     = 0;
	esselPrm3.outQueChInfo[0].numOutCh     = 3;
	esselPrm3.outQueParams[1].nextLink     = esnsfId0;
	esselPrm3.outQueChInfo[1].outQueId     = 1;
	esselPrm3.outQueChInfo[1].numOutCh     = 3;
	esselPrm3.outQueChInfo[0].inChNum[0] = 0;
	esselPrm3.outQueChInfo[0].inChNum[1] = 1;
	esselPrm3.outQueChInfo[0].inChNum[2] = 2;
	esselPrm3.outQueChInfo[1].inChNum[0] = 3;
	esselPrm3.outQueChInfo[1].inChNum[1] = 4;
	esselPrm3.outQueChInfo[1].inChNum[2] = 5;//*/

    esnsfPrm0.inQueParams.prevLinkId           = esselId3;
    esnsfPrm0.inQueParams.prevLinkQueId        = 1;
    esnsfPrm0.outQueParams[0].nextLink         = esmergeId4;
    esnsfPrm0.bypassNsf                        = TRUE;
    esnsfPrm0.tilerEnable                      = TRUE;
    esnsfPrm0.numOutQue                        = 1;
    esnsfPrm0.numBufsPerCh                     = 0;//*/

    esmergePrm4.numInQue		=	2;
    esmergePrm4.inQueParams[0].prevLinkId		=	esselId3;
    esmergePrm4.inQueParams[0].prevLinkQueId	=	0;
    esmergePrm4.inQueParams[1].prevLinkId		=	esnsfId0;
    esmergePrm4.inQueParams[1].prevLinkQueId	=	0;
    esmergePrm4.outQueParams.nextLink			=	esipcOutVpssId0;
//    esmergePrm4.outQueParams.nextLink			=	esnullId1;
    esmergePrm4.notifyNextLink	=	TRUE;//*/
/*
    esnullPrm1.numInQue					= 1;
    esnullPrm1.inQueParams[0].prevLinkId	= esmergeId4;
    esnullPrm1.inQueParams[0].prevLinkQueId= 0;//*/

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

    esipcOutVpssPrm0.inQueParams.prevLinkId    = esmergeId4;
    esipcOutVpssPrm0.inQueParams.prevLinkQueId = 0;
    esipcOutVpssPrm0.numOutQue                 = 1;
//    esipcOutVpssPrm0.numChPerOutQue[0]         = 1;
    esipcOutVpssPrm0.numChPerOutQue[0]         = 6;
    esipcOutVpssPrm0.outQueParams[0].nextLink  = esipcInVideoId0;
    esipcOutVpssPrm0.notifyNextLink            = TRUE;
//    esipcOutVpssPrm0.notifyPrevLink            = FALSE;
    esipcOutVpssPrm0.notifyPrevLink            = TRUE;
    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.numChPerOutQue[0]         = 6;
    esipcInVideoPrm0.outQueParams[0].nextLink  = esencId0;
//    esipcInVideoPrm0.outQueParams[0].nextLink  = esvideonullId0;	//for test vip resetting...
    esipcInVideoPrm0.notifyNextLink            = TRUE;
//    esipcInVideoPrm0.notifyPrevLink            = FALSE;
    esipcInVideoPrm0.notifyPrevLink            = TRUE;
    esipcInVideoPrm0.noNotifyMode              = FALSE;
//    esipcInVideoPrm0.numChPerOutQue[0]         = 0;
    esipcInVideoPrm0.equallyDivideChAcrossOutQues = FALSE;//*/
/*
    esvideonullPrm0.numInQue					= 1;
    esvideonullPrm0.inQueParams[0].prevLinkId	= esipcInVideoId0;
    esvideonullPrm0.inQueParams[0].prevLinkQueId= 0;//*/

    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                    = TRUE;//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.targetFrameRate     = 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;

        EncLink_ChDynamicParams *dynamicParams              = &esencPrm0.chCreateParams[i].defaultDynamicParams;
        dynamicParams->intraCodingParams.intraCodingPreset  = IH264_INTRACODING_USERDEFINED;
        dynamicParams->intraCodingParams.intraRefreshMethod = IH264_INTRAREFRESH_GDR;
        dynamicParams->intraCodingParams.intraRefreshRate   = GetChannelFrameRate(hChannel);
    }
    esencPrm0.inQueParams.prevLinkId   = esipcInVideoId0;
    esencPrm0.inQueParams.prevLinkQueId= 0;
    esencPrm0.outQueParams.nextLink    = esipcBitsOutVideoId0;
    esencPrm0.numBufPerCh[0]           = 16;
    esencPrm0.numBufPerCh[1]           = 16;
    esencPrm0.numBufPerCh[2]           = 16;
    esencPrm0.numBufPerCh[3]           = 16;//*/


    esipcBitsOutVideoPrm0.baseCreateParams.inQueParams.prevLinkId      = esencId0;
    esipcBitsOutVideoPrm0.baseCreateParams.inQueParams.prevLinkQueId   = 0;
    esipcBitsOutVideoPrm0.baseCreateParams.numOutQue                   = 1;
//    esipcBitsOutVideoPrm0.baseCreateParams.numChPerOutQue[0]           = 1;
    esipcBitsOutVideoPrm0.baseCreateParams.numChPerOutQue[0]           = 6;
    esipcBitsOutVideoPrm0.baseCreateParams.outQueParams[0].nextLink    = esipcBitsInHostId0;
    esipcBitsOutVideoPrm0.baseCreateParams.notifyNextLink              = TRUE;
    esipcBitsOutVideoPrm0.baseCreateParams.notifyPrevLink              = TRUE;
    esipcBitsOutVideoPrm0.baseCreateParams.noNotifyMode                = FALSE;

    esipcBitsInHostPrm0.baseCreateParams.inQueParams.prevLinkId        = esipcBitsOutVideoId0;
    esipcBitsInHostPrm0.baseCreateParams.inQueParams.prevLinkQueId     = 0;
    esipcBitsInHostPrm0.baseCreateParams.numOutQue                     = 1;
//    esipcBitsInHostPrm0.baseCreateParams.numChPerOutQue[0]             = 1;
    esipcBitsInHostPrm0.baseCreateParams.numChPerOutQue[0]             = 6;
    esipcBitsInHostPrm0.baseCreateParams.notifyNextLink                = TRUE;
    esipcBitsInHostPrm0.baseCreateParams.notifyPrevLink                = TRUE;
    esipcBitsInHostPrm0.baseCreateParams.noNotifyMode                  = FALSE;
    esipcBitsInHostPrm0.cbFxn = CbFxn_IPCBitsInHLOSLINK;
    esipcBitsInHostPrm0.cbCtx = &(ipc_ctrl.semFullIn);

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

    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(esselId3, &esselPrm3, sizeof(esselPrm3));
    System_linkCreate(esnsfId0, &esnsfPrm0, sizeof(esnsfPrm0));
    System_linkCreate(esmergeId4, &esmergePrm4, sizeof(esmergePrm4));

//    System_linkCreate(esnullId1, &esnullPrm1, sizeof(esnullPrm1));

    System_linkCreate(esipcOutVpssId0, &esipcOutVpssPrm0, sizeof(esipcOutVpssPrm0));
    System_linkCreate(esipcInVideoId0, &esipcInVideoPrm0, sizeof(esipcInVideoPrm0));

//    System_linkCreate(esvideonullId0, &esvideonullPrm0, sizeof(esvideonullPrm0));;

    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(esvideonullId0);

//        System_linkStart(esnullId1);

        System_linkStart(esmergeId4);
        System_linkStart(esnsfId0);
        System_linkStart(esselId3);

        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);

        voiceStimulateStart();

        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);
            }esvideonullId0
            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;esvideonullId0
            	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);
            }
        }

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


        PeripheralProcessEncodedDataStop();
        sleep(1);
        PeripheralGetStreamsStop();
        PutFullOutStop(&ipc_ctrl);
        GetEmptyOutStop(&ipc_ctrl);


        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(esselId3);
        System_linkStop(esnsfId0);
        System_linkStop(esmergeId4);

//        System_linkStop(esnullId1);

//        System_linkStop(esvideonullId0);

        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(esselId3);
    System_linkDelete(esnsfId0);
    System_linkDelete(esmergeId4);

//    System_linkDelete(esnullId1);

    System_linkDelete(esipcOutVpssId0);
    System_linkDelete(esipcInVideoId0);

//    System_linkDelete(esvideonullId0);//*/

    System_linkDelete(esencId0);
    System_linkDelete(esipcBitsOutVideoId0);
    System_linkDelete(esipcBitsInHostId0);//*/

    Chains_displayCtrlDeInit();
}

    Is my parameters setting wrong? Pls help me checking, Thanks!

    In order to verify sub-chain, to confirm if IpcInVideo LINK or Encode LINK doesn't work properly, I modify my usecase as following:

    (capture, Swms) ----> IpcOutVpss ----> IpcInVideo ----> SYSTEM_VIDEO_LINK_ID_NULL_0

    but the chain cannot run, with log infomation:

    6406.IpcOutVpss_IpcInVideo_VideoNull.txt

    (capture, Swms) ----> IpcOutVpss ----> IpcInVideo ----> Enc ----> SYSTEM_VIDEO_LINK_ID_NULL_0

    the chain still cannot run , with log information :

    2337.IpcOutVpss_IpcInVideo_Enc_VideoNull.txt

    I want to know

    1) how can I fix the issue capture overflow?

    2) how to use SYSTEM_VIDEO_LINK_ID_NULL_X correctly?

    Appreciate for any reply!

  • 0 in reply to Ri-Ping YU
    Intellectual 890 points

    Hi:

    What is your paltform and the PG version?

  • 0 in reply to Away.liu
    Expert 1460 points

    Hello, Mr. Liu

    Thanks for your reply!

    My platform is DM8168 and DVR_RDK 3.0,

    from the value of register ( 0x48140600 ) = 0x00000007, it looks like the PG version is  ES1.0;

    I have patched the relative file according to the suggestion mentioned in this post

    http://e2e.ti.com/support/dsp/davinci_digital_media_processors/f/717/t/254319.aspx?pi199607=1

    But there is no improvement, I cannot tell what happened

    Expect your further suggestion,

    Thanks a lot!