/*****************************/

#define ENABLE_FAKE_HD_MODE

#define NUM_CAPTURE_DEVICES        	(2)
#define NB_SNAP_CHANNEL 			(2)

#define TILER_ENABLE    FALSE //FALSE

/*IVA HD MAP Table*/
static SystemVideo_Ivahd2ChMap_Tbl _systemVid_encDecIvaChMapTbl =
{
    .isPopulated = 1,
    .ivaMap[0] =
    {
        .EncNumCh  = 1,
        .EncChList = {0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 , 0, 0},
        .DecNumCh  = 0,
        .DecChList = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
    },
};

int _nbChannelEncode = 0;

UInt32 _captureId;
UInt32 _encId;
UInt32 _mergeId;
UInt32 _deiId;
UInt32 _nsfId;
UInt32 _dup1Id;
UInt32 _dup2Id;

UInt32 _ipcBitsOutVpssId, _ipcBitsInVideoId;
UInt32 _ipcBitsOutVideoId, _ipcBitsInHostId;

VCAP_DEVICE_CREATE_PARAM_S _vidDecVideoModeArgs[NUM_CAPTURE_DEVICES];

void capture_encode_set_dei_prm(DeiLink_CreateParams *deiPrm, UInt32 outWidth, UInt32 outHeight, UInt32 inputFramerate, UInt32 deiOutId)
{
    UInt32 i, outId, chId;
    //UInt32 outIdList[] = { DEI_LINK_OUT_QUE_DEI_SC/*, DEI_LINK_OUT_QUE_VIP_SC */};

    deiPrm->comprEnable                 = FALSE;
    deiPrm->setVipScYuv422Format        = FALSE;
    deiPrm->inputDeiFrameRate           = inputFramerate;
    deiPrm->outputDeiFrameRate          = inputFramerate;
    deiPrm->enableDeiForceBypass        = TRUE;
    deiPrm->enableForceInterlacedInput  = FALSE;
    deiPrm->enableLineSkipSc            = FALSE;
    deiPrm->enableDualVipOut            = FALSE;
    deiPrm->enableInputFrameRateUpscale = FALSE;

    //for(i=0; i<OSA_ARRAYSIZE(outIdList); i++)
    //{
        //outId = outIdList[i];
        outId = deiOutId;

        deiPrm->enableOut[outId] = TRUE;

        deiPrm->tilerEnable[outId] = TILER_ENABLE;
        for(chId=0; chId< DEI_LINK_MAX_CH; chId++)
        {
            deiPrm->outScaleFactor[outId][chId].scaleMode = DEI_SCALE_MODE_ABSOLUTE;
            deiPrm->outScaleFactor[outId][chId].absoluteResolution.outWidth = outWidth;
            deiPrm->outScaleFactor[outId][chId].absoluteResolution.outHeight = outHeight;
            
        }

        deiPrm->inputFrameRate[outId]   = inputFramerate;
        deiPrm->outputFrameRate[outId]  = inputFramerate;

        deiPrm->numBufsPerCh[outId]     = 6;
        deiPrm->generateBlankOut[outId] = FALSE;
    //}
}

void capture_encode_set_nsf_prm(NsfLink_CreateParams * nsfPrm, UInt32 numBufPerCh, UInt32 inputFramerate,UInt32 outputFramerate)
{
    nsfPrm->numOutQue    = 1;
    nsfPrm->bypassNsf    = TRUE;
    nsfPrm->tilerEnable  = TILER_ENABLE; 
    nsfPrm->numBufsPerCh = numBufPerCh;
    nsfPrm->inputFrameRate = inputFramerate;
    nsfPrm->outputFrameRate = outputFramerate;
}

Void capture_set_capture_prm(CaptureLink_CreateParams *capturePrm,Config_struct *Pt_Conf, int8_t nbChannel)
{
    CaptureLink_VipInstParams         *pCaptureInstPrm;
    CaptureLink_OutParams             *pCaptureOutPrm;
    UInt32 vipInstId;

    capturePrm->isPalMode                   = TRUE;
    capturePrm->numVipInst                  = nbChannel;
    capturePrm->tilerEnable                 = TILER_ENABLE;
#ifdef ENABLE_FAKE_HD_MODE
    capturePrm->fakeHdMode                  = TRUE;
#else
    capturePrm->fakeHdMode                  = FALSE;
#endif
    capturePrm->enableSdCrop                = FALSE;
    capturePrm->doCropInCapture             = FALSE;
    capturePrm->numBufsPerCh                = 6;
    capturePrm->numExtraBufs                = 0;
    capturePrm->maxBlindAreasPerCh          = 0;
    capturePrm->overrideNumBufsInInstPrms   = 0;

    for(vipInstId=0; vipInstId<capturePrm->numVipInst; vipInstId++)
    {
        pCaptureInstPrm                     = &capturePrm->vipInst[vipInstId];
        if( vipInstId == 0 )
            pCaptureInstPrm->vipInstId          = SYSTEM_CAPTURE_INST_VIP0_PORTA;
        else
            pCaptureInstPrm->vipInstId          = SYSTEM_CAPTURE_INST_VIP1_PORTA;
            
        pCaptureInstPrm->videoDecoderId     = SYSTEM_DEVICE_VID_DEC_TVP5158_DRV;
        pCaptureInstPrm->standard           = VSYS_STD_PAL;
        pCaptureInstPrm->inDataFormat       = SYSTEM_DF_YUV422P;
        pCaptureInstPrm->numOutput          = 1;

        pCaptureInstPrm->inDataFormat       = SYSTEM_DF_YUV422P;
        pCaptureInstPrm->videoIfMode        = SYSTEM_CAPT_VIDEO_IF_MODE_8BIT;
        //pCaptureInstPrm->inScanFormat       = SYSTEM_SF_INTERLACED;
        pCaptureInstPrm->videoCaptureMode   = SYSTEM_CAPT_VIDEO_CAPTURE_MODE_SINGLE_CH_NON_MUX_EMBEDDED_SYNC;

        pCaptureOutPrm                      = &pCaptureInstPrm->outParams[0]; 
        pCaptureOutPrm->dataFormat          = SYSTEM_DF_YUV420SP_UV; //SYSTEM_DF_YUV422I_YUYV;
		pCaptureOutPrm->scEnable            = FALSE;
		pCaptureOutPrm->scOutWidth          = 0;
		pCaptureOutPrm->scOutHeight         = 0;

        pCaptureOutPrm->outQueId            = 0;
    }
}
void capture_configure_extvideodecoder_prm(Config_struct *Pt_Conf, int8_t nbChannel)
{
    int i;
    Int32 status = 0;
    uint32_t numCaptureDevices = nbChannel;
    
    for(i = 0; i < numCaptureDevices; i++)
    {
        if( i == 0 )
            _vidDecVideoModeArgs[i].vipInstId        = SYSTEM_CAPTURE_INST_VIP0_PORTA; /* capture on VIP 0 */
        else
            _vidDecVideoModeArgs[i].vipInstId        = SYSTEM_CAPTURE_INST_VIP1_PORTA; /* capture on VIP 1 */
        _vidDecVideoModeArgs[i].deviceId         = DEVICE_VID_DEC_TVP5158_DRV;
        _vidDecVideoModeArgs[i].numChInDevice    = 1; //4

        _vidDecVideoModeArgs[i].modeParams.videoIfMode        = DEVICE_CAPT_VIDEO_IF_MODE_8BIT;
        _vidDecVideoModeArgs[i].modeParams.videoDataFormat    = SYSTEM_DF_YUV422P;
        _vidDecVideoModeArgs[i].modeParams.standard           = VSYS_STD_PAL;
        _vidDecVideoModeArgs[i].modeParams.videoCaptureMode   =
                    DEVICE_CAPT_VIDEO_CAPTURE_MODE_SINGLE_CH_NON_MUX_EMBEDDED_SYNC;
        _vidDecVideoModeArgs[i].modeParams.videoSystem        =
                                      DEVICE_VIDEO_DECODER_VIDEO_SYSTEM_AUTO_DETECT;
        _vidDecVideoModeArgs[i].modeParams.videoCropEnable    = FALSE;
        _vidDecVideoModeArgs[i].modeParams.videoAutoDetectTimeout = -1;
    }
    status = Vcap_deviceCreate(_vidDecVideoModeArgs, numCaptureDevices);
    printf("LOG :  create tv5158 status = 0x%X\n",status);
}

void capture_encode_create(Config_struct *Pt_Conf)
{
    CaptureLink_CreateParams    capturePrm;
    DeiLink_CreateParams        deiPrm;
    NsfLink_CreateParams        nsfPrm;
    MergeLink_CreateParams      mergePrm;

    IpcLink_CreateParams        ipcOutVpssPrm;
    IpcLink_CreateParams        ipcInVideoPrm;

    EncLink_CreateParams        encPrm;  
    DupLink_CreateParams        dup1Prm;   
    DupLink_CreateParams        dup2Prm;   
    
    IpcBitsOutLinkRTOS_CreateParams   ipcBitsOutVideoPrm;
    IpcBitsInLinkHLOS_CreateParams    ipcBitsInHostPrm;

    CaptureLink_VipInstParams *pCaptureInstPrm = NULL;
    CaptureLink_OutParams     *pCaptureOutPrm = NULL;
    
    UInt32 vipInstId;
    UInt32 i/*, status*/;

    printf("LOG :  capture_encode_start\n");
    _captureId            = SYSTEM_LINK_ID_CAPTURE;
    _deiId                = SYSTEM_LINK_ID_DEI_HQ_0;
    _nsfId                = SYSTEM_LINK_ID_NSF_0;
    _mergeId              = SYSTEM_VPSS_LINK_ID_MERGE_0;
    _encId                = SYSTEM_LINK_ID_VENC_0;   
    _dup1Id               = SYSTEM_VPSS_LINK_ID_DUP_0;
    _dup2Id               = SYSTEM_VPSS_LINK_ID_DUP_1;
    
    _ipcBitsOutVpssId     = SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0;
    _ipcBitsInVideoId     = SYSTEM_VIDEO_LINK_ID_IPC_IN_M3_0;
    
    _ipcBitsOutVideoId    = SYSTEM_VIDEO_LINK_ID_IPC_BITS_OUT_0;
    _ipcBitsInHostId      = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_0;

    System_linkControl(
        SYSTEM_LINK_ID_M3VPSS,
        SYSTEM_M3VPSS_CMD_RESET_VIDEO_DEVICES,
        NULL,
        0,
        TRUE
    );
	_nbChannelEncode = 2;
    _systemVid_encDecIvaChMapTbl.ivaMap[0].EncNumCh = _nbChannelEncode + NB_SNAP_CHANNEL;
	
    System_linkControl(
        SYSTEM_LINK_ID_M3VIDEO,
        SYSTEM_COMMON_CMD_SET_CH2IVAHD_MAP_TBL,
        &_systemVid_encDecIvaChMapTbl,
        sizeof(SystemVideo_Ivahd2ChMap_Tbl),
        TRUE
    );
    
    CHAINS_INIT_STRUCT(CaptureLink_CreateParams, capturePrm);
    CHAINS_INIT_STRUCT(IpcLink_CreateParams, ipcOutVpssPrm);
    CHAINS_INIT_STRUCT(IpcLink_CreateParams, ipcInVideoPrm);
    CHAINS_INIT_STRUCT(EncLink_CreateParams, encPrm);
    CHAINS_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams, ipcBitsOutVideoPrm);
    CHAINS_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams, ipcBitsInHostPrm);
    DeiLink_CreateParams_Init(&deiPrm);
    NsfLink_CreateParams_Init(&nsfPrm);
    
/** CAPTURE */    
    capture_configure_extvideodecoder_prm(Pt_Conf,_nbChannelEncode);
    capturePrm.outQueParams[0].nextLink = _dup1Id ;
    capturePrm.outQueParams[1].nextLink = _dup2Id;    
    capture_set_capture_prm(&capturePrm,Pt_Conf,_nbChannelEncode);
      
/** DUPLICATE */
    dup1Prm.inQueParams.prevLinkId  = _captureId;
    dup1Prm.inQueParams.prevLinkQueId   = 0;
    dup1Prm.numOutQue                   = 2;
    dup1Prm.notifyNextLink              = TRUE;
    dup1Prm.outQueParams[0].nextLink        = _mergeId;

    dup2Prm.inQueParams.prevLinkId  = _captureId;
    dup2Prm.inQueParams.prevLinkQueId   = 1;
    dup2Prm.numOutQue                   = 2;
    dup2Prm.notifyNextLink              = TRUE;
    dup2Prm.outQueParams[0].nextLink        = _mergeId;
     
/** MERGE */    
    mergePrm.numInQue = _nbChannelEncode + NB_SNAP_CHANNEL; 
    mergePrm.inQueParams[0].prevLinkId       = _dup1Id;  
    mergePrm.inQueParams[0].prevLinkQueId    = 0;
          
	mergePrm.inQueParams[2].prevLinkId       = _dup1Id;
	mergePrm.inQueParams[2].prevLinkQueId    = 1;
	
	mergePrm.inQueParams[1].prevLinkId       = _dup2Id;
	mergePrm.inQueParams[1].prevLinkQueId    = 0;
	mergePrm.inQueParams[3].prevLinkId       = _dup2Id;
	mergePrm.inQueParams[3].prevLinkQueId    = 1;   
     
    mergePrm.notifyNextLink             = TRUE;
    mergePrm.outQueParams.nextLink  	= _deiId;
/** DEI */    
    capture_encode_set_dei_prm(&deiPrm, 1920, 1080,Pt_Conf->framerate[0], DEI_LINK_OUT_QUE_DEI_SC );
    deiPrm.inQueParams.prevLinkId    = _mergeId;
    deiPrm.inQueParams.prevLinkQueId = 0;
    deiPrm.outQueParams[DEI_LINK_OUT_QUE_DEI_SC].nextLink = _nsfId;
/** NSF */    
    capture_encode_set_nsf_prm(&nsfPrm, 3, Pt_Conf->framerate[0],Pt_Conf->framerate[0]);
    nsfPrm.inQueParams.prevLinkId    = _deiId;
    nsfPrm.inQueParams.prevLinkQueId = 0;
    nsfPrm.outQueParams[0].nextLink  = _ipcBitsOutVpssId;
/**IPC OUT VPSS */
    ipcOutVpssPrm.inQueParams.prevLinkId    = _nsfId;
    ipcOutVpssPrm.inQueParams.prevLinkQueId = 0;
    ipcOutVpssPrm.numOutQue                 = 1;
    ipcOutVpssPrm.notifyNextLink            = TRUE;
    ipcOutVpssPrm.notifyPrevLink            = TRUE;
    ipcOutVpssPrm.noNotifyMode              = FALSE;
    //ipcOutVpssPrm.notifyProcessLink         = FALSE;
    ipcOutVpssPrm.outQueParams[0].nextLink  = _ipcBitsInVideoId;
    ipcOutVpssPrm.numChPerOutQue[0]  = _nbChannelEncode + NB_SNAP_CHANNEL; 
    
/** IPC IN HVICP */
    printf("LOG :  ipcBitsOutVpss to ipcBitsInVideo\n");
    ipcInVideoPrm.inQueParams.prevLinkId    = _ipcBitsOutVpssId;
    ipcInVideoPrm.inQueParams.prevLinkQueId = 0;
    ipcInVideoPrm.numOutQue                 = 1;
    ipcInVideoPrm.notifyNextLink            = TRUE;
    ipcInVideoPrm.notifyPrevLink            = TRUE;
    ipcInVideoPrm.noNotifyMode              = FALSE; 
    ipcInVideoPrm.outQueParams[0].nextLink  = _encId;
    ipcInVideoPrm.numChPerOutQue[0]  = _nbChannelEncode + NB_SNAP_CHANNEL; 
    
/** ENC HVICP */
    printf("LOG :  ipcBitsInVideo to Encoder\n");
    EncLink_ChCreateParams *pLinkChPrm = NULL;
    EncLink_ChDynamicParams *pLinkDynPrm  = NULL;
    
    encPrm.inQueParams.prevLinkId   = _ipcBitsInVideoId;
    encPrm.inQueParams.prevLinkQueId= 0;
    encPrm.outQueParams.nextLink = _ipcBitsOutVideoId;
    
    for( i = 0 ; i < _nbChannelEncode + NB_SNAP_CHANNEL ; i++ )
    {
        pLinkChPrm  = &encPrm.chCreateParams[i];
        pLinkDynPrm = &pLinkChPrm->defaultDynamicParams;
        printf("LOG :  Configure Encoder %d\n",i);
        encPrm.numBufPerCh[i] = 6;
        if( i < _nbChannelEncode ) /* ch id 0 and 1 in H264 */
        {    
            if( Pt_Conf->codec == VCODEC_TYPE_H264 )
            {
                pLinkChPrm->format                  = IVIDEO_H264HP;
                pLinkChPrm->profile                 = IH264_HIGH_PROFILE;
                pLinkChPrm->enableAnalyticinfo      = 1;
                pLinkChPrm->enableWaterMarking      = 1;
                pLinkChPrm->maxBitRate              = 4000 * 1000 ;
                pLinkChPrm->encodingPreset          = VENC_XDM_DEFAULT;
                pLinkChPrm->rateControlPreset       = VENC_RATE_CTRL_VBR; //IVIDEO_STORAGE
                pLinkChPrm->enableHighSpeed         = FALSE; /* enable only if encodingPreset is set to VENC_XDM_USER_DEFINED*/
                pLinkChPrm->overrideInputScanFormat = FALSE; 
                pLinkChPrm->fieldPicEncode = FALSE; 

                pLinkDynPrm->intraFrameInterval     = 25;
                pLinkDynPrm->targetBitRate          = 4000 * 1000 ;
                pLinkDynPrm->interFrameInterval     = 1;
                pLinkDynPrm->mvAccuracy             = IVIDENC2_MOTIONVECTOR_QUARTERPEL;
                pLinkDynPrm->rcAlg                  = 0;//VENC_RATE_CTRL_VBR;
                pLinkDynPrm->qpMin                  = 10;
                pLinkDynPrm->qpMax                  = 40;
                pLinkDynPrm->qpInit                 = -1;
                pLinkDynPrm->vbrDuration            = 8;
                pLinkDynPrm->vbrSensitivity         = 0;
				pLinkChPrm->fieldMergeEncodeEnable = FALSE;
                pLinkChPrm->dataLayout = VCODEC_FIELD_SEPARATED; /*IVIDEO_PROGRESSIVE;*/
#if 0
                switch(Pt_Conf->res[i])
                {
                    case VSYS_STD_NTSC:
                    case VSYS_STD_PAL:
                    case VSYS_STD_480I:
                    case VSYS_STD_576I:
                    case VSYS_STD_CIF:
                    case VSYS_STD_HALF_D1:
                    case VSYS_STD_D1:
                    case VSYS_STD_1080I_60:
                    case VSYS_STD_1080I_50:
                        //pLinkChPrm->fieldMergeEncodeEnable = TRUE;
                        pLinkChPrm->fieldMergeEncodeEnable = FALSE;
                        pLinkChPrm->dataLayout = IVIDEO_FIELD_INTERLEAVED; /*IVIDEO_INTERLACED;*/
                        break;
                    case VSYS_STD_480P:
                    case VSYS_STD_576P:
                    case VSYS_STD_720P_60:
                    case VSYS_STD_720P_50:
                    case VSYS_STD_1080P_60:
                    case VSYS_STD_1080P_50:
                    case VSYS_STD_1080P_24:
                    case VSYS_STD_1080P_30:
                    default:
                        pLinkChPrm->fieldMergeEncodeEnable = FALSE;
                        pLinkChPrm->dataLayout = VCODEC_FIELD_SEPARATED; /*IVIDEO_PROGRESSIVE;*/
                        break;
                }
#endif					
            }
        }
        else /* ch id 2 and 3 in MJPEG */
        {
            pLinkChPrm->format                 = IVIDEO_MJPEG;
            pLinkChPrm->profile                = 0;
            pLinkChPrm->dataLayout             = VCODEC_FIELD_SEPARATED;
            pLinkChPrm->fieldMergeEncodeEnable = FALSE;
            pLinkChPrm->enableAnalyticinfo     = 0;
            pLinkChPrm->enableWaterMarking     = 0;
            pLinkChPrm->maxBitRate             = 0 ;
            pLinkChPrm->encodingPreset         = 0;
            pLinkChPrm->rateControlPreset      = 0;
            pLinkChPrm->enableSVCExtensionFlag = 0;
            pLinkChPrm->numTemporalLayer       = 0;

            pLinkDynPrm->intraFrameInterval    = 0;
            pLinkDynPrm->targetBitRate         = 10000 * 1000 * 10;
            pLinkDynPrm->interFrameInterval    = 0;
            pLinkDynPrm->mvAccuracy            = 0;
            pLinkDynPrm->inputFrameRate        = 25 ;
            pLinkDynPrm->qpMin                 = 0;
            pLinkDynPrm->qpMax                 = 0;
            pLinkDynPrm->qpInit                = 97 ; 
            pLinkDynPrm->vbrDuration           = 0;
            pLinkDynPrm->vbrSensitivity        = 0;
        }
    }
/** IPC OUT HDVICP */
    printf("LOG :  Encoder to ipcBitsOutVideo\n");
    ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkId = _encId;
    ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
    ipcBitsOutVideoPrm.baseCreateParams.numOutQue                 = 1;
    ipcBitsOutVideoPrm.baseCreateParams.outQueParams[0].nextLink = _ipcBitsInHostId;
    ipcBitsOutVideoPrm.baseCreateParams.numChPerOutQue[0]  = _nbChannelEncode + NB_SNAP_CHANNEL; 
    capture_encode_ipcBitsInitCreateParams_BitsOutRTOS(&ipcBitsOutVideoPrm, TRUE);
/** IPC IN ARM */
    ipcBitsInHostPrm.baseCreateParams.inQueParams.prevLinkId = _ipcBitsOutVideoId;
    ipcBitsInHostPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
    ipcBitsInHostPrm.baseCreateParams.numOutQue                 = 1;
    ipcBitsInHostPrm.baseCreateParams.outQueParams[0].nextLink   = SYSTEM_LINK_ID_INVALID;
    ipcBitsInHostPrm.baseCreateParams.numChPerOutQue[0]  = 0;
    capture_encode_ipcBitsInitCreateParams_BitsInHLOS(&ipcBitsInHostPrm);

    printf("LOG :  System_linkCreate _captureId\n");
    System_linkCreate(_captureId, &capturePrm, sizeof(capturePrm));
    printf("LOG :  System_linkCreate _dup1Id\n");
    System_linkCreate(_dup1Id, &dup1Prm, sizeof(dup1Prm));    
    System_linkCreate(_dup2Id, &dup2Prm, sizeof(dup2Prm));  
    printf("LOG :  System_linkCreate _mergeId\n");
    System_linkCreate(_mergeId, &mergePrm, sizeof(mergePrm));
    printf("LOG :  System_linkCreate _deiId\n");
    System_linkCreate(_deiId, &deiPrm, sizeof(DeiLink_CreateParams));
    printf("LOG :  System_linkCreate _nsfId \n");
    System_linkCreate(_nsfId,&nsfPrm, sizeof(NsfLink_CreateParams));
    printf("LOG :  System_linkCreate _ipcBitsOutVpssId\n");
    System_linkCreate(_ipcBitsOutVpssId, &ipcOutVpssPrm, sizeof(ipcOutVpssPrm));
    printf("LOG :  System_linkCreate _ipcBitsInVideoId\n");
    System_linkCreate(_ipcBitsInVideoId, &ipcInVideoPrm, sizeof(ipcInVideoPrm));
    printf("LOG :  System_linkCreate _encId\n");
    System_linkCreate(_encId, &encPrm, sizeof(encPrm));
    printf("LOG :  System_linkCreate _ipcBitsOutVideoId\n");
    System_linkCreate(_ipcBitsOutVideoId, &ipcBitsOutVideoPrm, sizeof(ipcBitsOutVideoPrm));
    printf("LOG :  System_linkCreate _ipcBitsInHostId\n");
    System_linkCreate(_ipcBitsInHostId, &ipcBitsInHostPrm, sizeof(ipcBitsInHostPrm));
  
	capture_encode_start(Pt_Conf);
}

void capture_encode_start(Config_struct *Pt_Conf)
{
    printf("LOG :  System_linkStart _ipcBitsInHostId\n");
    System_linkStart(_ipcBitsInHostId);
    printf("LOG :  System_linkStart _ipcBitsOutVideoId\n");
    System_linkStart(_ipcBitsOutVideoId);
    printf("LOG :  System_linkStart _encId\n");
    System_linkStart(_encId);
    printf("LOG :  System_linkStart _ipcBitsInVideoId\n");
    System_linkStart(_ipcBitsInVideoId);
    printf("LOG :  System_linkStart _ipcBitsOutVpssId\n");
    System_linkStart(_ipcBitsOutVpssId);
    printf("LOG :  System_linkStart _nsfId\n");
    System_linkStart(_nsfId);
    printf("LOG :  System_linkStart _deiId\n");
    System_linkStart(_deiId);
    printf("LOG :  System_linkStart _mergeId\n");
    System_linkStart(_mergeId);  
    printf("LOG :  System_linkStart _dup1Id\n");
    System_linkStart(_dup1Id);     
    System_linkStart(_dup2Id);    
    printf("LOG :  System_linkStart _captureId\n");
    System_linkStart(_captureId);
    Vcap_deviceStart();
}

void capture_encode_stop(Config_struct *Pt_Conf)
{
    Vcap_deviceStop();
    printf("LOG :  capture_encode_stop\n");
    System_linkStop(_captureId);
    System_linkStop(_nsfId);
    System_linkStop(_deiId); 
    System_linkStop(_mergeId);   
    System_linkStop(_dup1Id);   
    System_linkStop(_dup2Id);  
    System_linkStop(_ipcBitsOutVpssId);
    System_linkStop(_ipcBitsInVideoId);
    System_linkStop(_encId);
    System_linkStop(_ipcBitsOutVideoId);
    System_linkStop(_ipcBitsInHostId);
	
    System_linkDelete(_captureId);
    System_linkDelete(_nsfId);
    System_linkDelete(_deiId);        
    System_linkDelete(_mergeId); 
    System_linkDelete(_dup1Id);    
    System_linkDelete(_dup2Id); 
    System_linkDelete(_ipcBitsOutVpssId);
    System_linkDelete(_ipcBitsInVideoId);
    System_linkDelete(_encId);
    System_linkDelete(_ipcBitsOutVideoId);
    System_linkDelete(_ipcBitsInHostId);
}