How to encode 4ch D1 and 1ch HD(1080P) at the same time

/*******************************************************************************
 *                                                                             *
 * Copyright (c) 2009 Texas Instruments Incorporated - http://www.ti.com/      *
 *                        ALL RIGHTS RESERVED                                  *
 *                                                                             *
 ******************************************************************************/


#include "mcfw/src_linux/mcfw_api/usecases/multich_common.h"
#include "mcfw/src_linux/mcfw_api/usecases/multich_ipcbits.h"
#include "mcfw/src_linux/mcfw_api/ti_vdis_priv.h"
#include "mcfw/src_linux/devices/tw2968/src/tw2968_priv.h"
#include "mcfw/src_linux/devices/tvp5158/src/tvp5158_priv.h"
#include "mcfw/interfaces/link_api/system_tiler.h"
#include "mcfw/interfaces/link_api/avsync_hlos.h"
#include "mcfw/interfaces/ti_vdis_timings.h"

/* =============================================================================
 * Externs
 * =============================================================================
 */

/* =============================================================================
 * Use case code
 * =============================================================================
 */

/**


               +--------------+
               |              |
               |              |
               |   Capture    |
               |              |
               |              |
               +--------------+
                  +         +
                  |         +
          VIP0    |         |VIP1
          4ch SD  |         |1ch HD
            @     |         | @
         60 fields|         |30 frames
                  |         |
                  |         |
                  |         |
                  v         |
             +---------+    |
             |         |    |
             | DEI     |    |
             |         |    |
             +---------+    |
                  +         |
         4ch SD   |         v
           @  +-----------------+                      +----------+             +------------+
         30   |   Merge         |+-------------------->| H264 enc |+----------->|IpcBitsOut  |
      frames  |                 |                      |  5 ch    |             |            |
              +-----------------+                      +----------+             +------------+
*/

#define     MAX_NUM_CAPTURE_DEVICES     (4)

#define     NUM_SD_DECODE_CHANNELS      (4)
#define     NUM_HD_DECODE_CHANNELS      (1)
#define     SD_DECODE_CHANNEL_WIDTH     (720)
#define     SD_DECODE_CHANNEL_HEIGHT     (576)
#define     HD_DECODE_CHANNEL_WIDTH     (1920)
#define     HD_DECODE_CHANNEL_HEIGHT     (1080)

#define     MULTICH_HDSDI_DVR_USECASE_MAX_NUM_LINKS       (64)

#define     MULTICH_DSP_ALG_LINK_OSD_IDX  (0)
#define     MULTICH_DSP_ALG_LINK_SCD_IDX  (1)

#define     OSD_VID_PLANE_FMT_420         (0)
#define     OSD_VID_PLANE_FMT_422         (1)

#define     NUM_BUFS_PER_CH_CAPTURE              (8)
#define     NUM_BUFS_PER_CH_DEI_VIP_SC_PRIQ      (6)
#define     NUM_BUFS_PER_CH_DEC_SD               (6)
#define     NUM_BUFS_PER_CH_DEC_HD               (4)
#define     NUM_BUFS_PER_CH_SWMS_HD              (4)
#define     NUM_BUFS_PER_CH_SWMS_SD              (4)
#define     NUM_BUFS_PER_CH_ENC_PRI              (5)
#define     NUM_BUFS_PER_CH_ENC_SEC              (5)
#define     NUM_BUFS_PER_CH_ENC_TER              (3)
#define     NUM_BUFS_PER_CH_BITSOUT_SD           (5)
#define     NUM_BUFS_PER_CH_BITSOUT_HD           (4)
#define     NUM_BUFS_PER_CH_SCLR                 (3)
#define     NUM_BUFS_PER_CH_BITSOUT_SCD          (2)
#define     NUM_BUFS_PER_CH_NSF                  (3)



#define     ENC_LINK_PRIMARY_STREAM_POOL_ID      (0)

#define     IPCBITSOUT_LINK_SD_STREAM_POOL_ID    (0)
#define     IPCBITSOUT_LINK_HD_STREAM_POOL_ID    (1)

#define     TILER_ENABLE_ENCODE                  (TRUE)
#define     TILER_ENABLE_DECODE_SD               (TRUE)
#define     TILER_ENABLE_DECODE_HD               (FALSE)

#define     HDSDIDVR_960H_LAYOUT_WIDTH          (960)
#define     HDSDIDVR_960H_LAYOUT_HEIGHT         (720)
/* =============================================================================
 * Externs
 * =============================================================================
 */


/* =============================================================================
 * Use case code
 * =============================================================================
 */

static SystemVideo_Ivahd2ChMap_Tbl systemVid_encDecIvaChMapTbl =
{
    .isPopulated = 1,
    .ivaMap[0] =
    {
        .EncNumCh  = 4,
        .EncChList = {0, 1, 2, 3, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42, 45, 48, 51, 54, 57, 60, 63},
        .DecNumCh  = 0,
        .DecChList = {0, 3, 6, 9, 12, 15, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    },
    .ivaMap[1] =
    {
        .EncNumCh  = 1,
        .EncChList = {5, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46, 49, 52, 55, 58, 61 },
        .DecNumCh  = 0,
        .DecChList = {1, 4, 7, 10, 13, 16, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    },
    .ivaMap[2] =
    {
        .EncNumCh  = 0,
        .EncChList = {2, 5, 8, 11, 14, 17, 20, 23, 26, 29, 32, 35, 38, 41, 44, 47, 50, 53, 56, 59, 62 },
        .DecNumCh  = 0,
        .DecChList = {2, 5, 8, 11, 14, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
    },
};

/** Merge Link Info */
#define     NUM_MERGE_LINK                         (1)


/**  D1 HD Merge
 *   DEI0 ------DEI_VIP_SC_PRI_Q-->Q0--|
 *                                     |-PRE_ENCODE_MERGE_LINK_IDX
 *   CAPTURE ---HD---------------->Q1--|
 *
 */
#define     PRE_ENCODE_MERGE_LINK_IDX              0
#define     PRE_ENCODE_MERGE_LINK_NUM_INQUE       (2)
#define     PRE_ENCODE_MERGE_LINK_DEI0_D1_QIDX    (0)
#define     PRE_ENCODE_MERGE_LINK_HDCAPTURE_QIDX    (1)


#define     NUM_DUP_LINK                           1
#define     DECODE_DUP_LINK_IDX                    0




#define     MULTICH_HDSDIDVR_MAPDEILINKID2INDEX(linkID)   (((linkID) == SYSTEM_LINK_ID_DEI_HQ_0) ? 0 : 1)

typedef struct MultichHDSDIDVR_Context
{
    UInt32 mergeId[NUM_MERGE_LINK];
    UInt32 dupId[NUM_DUP_LINK];
    UInt32 ipcOutVpssId, ipcInVpssId;
    UInt32 ipcOutVideoId, ipcInVideoId;
    UInt32 createdLinkCount;
    UInt32 createdLinks[MULTICH_HDSDI_DVR_USECASE_MAX_NUM_LINKS];
    CaptureLink_CreateParams    capturePrm;
    DeiLink_CreateParams        deiPrm[MAX_DEI_LINK];
    MergeLink_CreateParams      mergePrm[NUM_MERGE_LINK];
    DupLink_CreateParams        dupPrm[NUM_DUP_LINK];
    SwMsLink_CreateParams       swMsPrm[VDIS_DEV_MAX];
    DisplayLink_CreateParams    displayPrm[VDIS_DEV_MAX];
    IpcLink_CreateParams        ipcOutVpssPrm;
    IpcLink_CreateParams        ipcInVpssPrm;
    IpcLink_CreateParams        ipcOutVideoPrm;
    IpcLink_CreateParams        ipcInVideoPrm;
    EncLink_CreateParams        encPrm;
    DecLink_CreateParams        decPrm;
    IpcBitsOutLinkHLOS_CreateParams   ipcBitsOutHostPrm;
    IpcBitsOutLinkRTOS_CreateParams   ipcBitsOutVideoPrm;
    IpcBitsInLinkHLOS_CreateParams    ipcBitsInHostPrm[1];
    IpcBitsInLinkRTOS_CreateParams    ipcBitsInVideoPrm;
    VCAP_DEVICE_CREATE_PARAM_S vidDecVideoModeArgs[MAX_NUM_CAPTURE_DEVICES];
    AvsyncLink_LinkSynchConfigParams       avsyncCfg[2];
    UInt32                                 captureFps;
    MergeLink_InLinkChInfo                 mergeChMap[2];
    SwMsLink_LayoutPrm                     swmsLayoutPrm[VDIS_DEV_MAX];
    System_LinkInfo                        deiLinkInfo[2];
    VDIS_MOSAIC_S                          vdisMosaicPrms[VDIS_DEV_MAX];
    UInt32                                 invisbleDecChannelList[DEC_LINK_MAX_CH];
    UInt32                                 visbleDecChannelList[DEC_LINK_MAX_CH];
}  MultichHDSDIDVR_Context;

MultichHDSDIDVR_Context gHDSDIDVRUsecaseContext =
{
    .createdLinkCount           = 0
};

#ifdef MAX
#undef MAX
#endif

#define MAX(a,b) ((a) > (b) ? (a) : (b))

#define MULTICH_HDSDIDVR_GET_CAPTURE_FIELDS_PER_SEC()           (gHDSDIDVRUsecaseContext.captureFps)
#define MULTICH_HDSDIDVR_GET_CAPTURE_FRAMES_PER_SEC()           (gHDSDIDVRUsecaseContext.captureFps/2)

static
Int32 MultiCh_hdsdiDVRSetMosaicParams(VDIS_DEV vdDevId, VDIS_MOSAIC_S *psVdMosaicParam );

static Void multich_hdsdidvr_register_created_link(MultichHDSDIDVR_Context *pContext,
                                                    UInt32 linkID)
{
    OSA_assert(pContext->createdLinkCount < OSA_ARRAYSIZE(pContext->createdLinks));
    pContext->createdLinks[pContext->createdLinkCount] = linkID;
    pContext->createdLinkCount++;
}

#define MULTICH_HDSDIDVR_CREATE_LINK(linkID,createPrm,createPrmSize)           \
    do                                                                          \
    {                                                                           \
        System_linkCreate(linkID,createPrm,createPrmSize);                      \
        multich_hdsdidvr_register_created_link(&gHDSDIDVRUsecaseContext,      \
                                                linkID);                        \
    } while (0)

static
Void multich_hdsdidvr_reset_link_prms()
{
    int i;

    MULTICH_INIT_STRUCT(IpcLink_CreateParams,gHDSDIDVRUsecaseContext.ipcOutVpssPrm);
    MULTICH_INIT_STRUCT(IpcLink_CreateParams,gHDSDIDVRUsecaseContext.ipcInVpssPrm);
    MULTICH_INIT_STRUCT(IpcLink_CreateParams,gHDSDIDVRUsecaseContext.ipcOutVideoPrm);
    MULTICH_INIT_STRUCT(IpcLink_CreateParams,gHDSDIDVRUsecaseContext.ipcInVideoPrm);
    MULTICH_INIT_STRUCT(IpcBitsOutLinkRTOS_CreateParams,gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm);
    MULTICH_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[0]);
    MULTICH_INIT_STRUCT(IpcBitsInLinkHLOS_CreateParams,gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[1]);
    MULTICH_INIT_STRUCT(IpcBitsInLinkRTOS_CreateParams,gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm);
    IpcBitsOutLinkHLOS_CreateParams_Init(&gHDSDIDVRUsecaseContext.ipcBitsOutHostPrm);
    DecLink_CreateParams_Init(&gHDSDIDVRUsecaseContext.decPrm);
    EncLink_CreateParams_Init(&gHDSDIDVRUsecaseContext.encPrm);
    CaptureLink_CreateParams_Init(&gHDSDIDVRUsecaseContext.capturePrm);
    for (i = 0; i < OSA_ARRAYSIZE(gHDSDIDVRUsecaseContext.displayPrm);i++)
    {
        DisplayLink_CreateParams_Init(&gHDSDIDVRUsecaseContext.displayPrm[i]);
    }
    for (i = 0; i < OSA_ARRAYSIZE(gHDSDIDVRUsecaseContext.swMsPrm);i++)
    {
        SwMsLink_CreateParams_Init(&gHDSDIDVRUsecaseContext.swMsPrm[i]);
    }

     for (i = 0; i < OSA_ARRAYSIZE(gHDSDIDVRUsecaseContext.deiPrm);i++)
     {
         DeiLink_CreateParams_Init(&gHDSDIDVRUsecaseContext.deiPrm[i]);
     }
     for (i = 0; i < OSA_ARRAYSIZE(gHDSDIDVRUsecaseContext.avsyncCfg);i++)
     {
         AvsyncLink_LinkSynchConfigParams_Init(&gHDSDIDVRUsecaseContext.avsyncCfg[i]);
     }
}

static
Void multich_hdsdidvr_set_capture_prm(CaptureLink_CreateParams *capturePrm)
{
    CaptureLink_VipInstParams         *pCaptureInstPrm;
    CaptureLink_OutParams             *pCaptureOutPrm;
    UInt32 vipInstId;

    /* This is for TVP5158 Audio Channels - Change it to 16 if there are 16 audio channels connected in cascade */
    capturePrm->numVipInst                 = 2;

    capturePrm->tilerEnable                = FALSE;
    capturePrm->numBufsPerCh               = NUM_BUFS_PER_CH_CAPTURE;
    capturePrm->numExtraBufs               = 0;
    capturePrm->fakeHdMode                 = TRUE;
    capturePrm->enableSdCrop               = FALSE;
    capturePrm->doCropInCapture            = FALSE;
#ifndef SYSTEM_USE_VIDEO_DECODER
    capturePrm->isPalMode = Vcap_isPalMode();
#endif

    vipInstId = 0;
    pCaptureInstPrm                     = &capturePrm->vipInst[vipInstId];
    pCaptureInstPrm->vipInstId          = (SYSTEM_CAPTURE_INST_VIP0_PORTA+
                                          vipInstId)%SYSTEM_CAPTURE_INST_MAX;
    pCaptureInstPrm->videoDecoderId     = SYSTEM_DEVICE_VID_DEC_TVP5158_DRV;
    pCaptureInstPrm->inDataFormat       = SYSTEM_DF_YUV422P;
    pCaptureInstPrm->standard           = SYSTEM_STD_MUX_4CH_D1;
    pCaptureInstPrm->numOutput          = 1;

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

    vipInstId = 1;
    pCaptureInstPrm                     = &capturePrm->vipInst[vipInstId];
    pCaptureInstPrm->vipInstId          = (SYSTEM_CAPTURE_INST_VIP0_PORTA+
                                          vipInstId)%SYSTEM_CAPTURE_INST_MAX;
    pCaptureInstPrm->videoDecoderId     = SYSTEM_DEVICE_VID_DEC_SII9135_DRV;
    pCaptureInstPrm->inDataFormat       = SYSTEM_DF_YUV422P;
    pCaptureInstPrm->standard           = SYSTEM_STD_1080P_60;
    pCaptureInstPrm->numOutput          = 1;

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

}


static
Void multich_hdsdidvr_configure_extvideodecoder_prm()
{
    int i;
    VCAP_VIDEO_SOURCE_STATUS_S vidSourceStatus;
    UInt32 numCaptureDevices;

    numCaptureDevices = 2;

    for(i = 0; i < numCaptureDevices; i++)
    {
        if (0 == i)
        {
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].deviceId         = DEVICE_VID_DEC_TVP5158_DRV;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].vipInstId        = SYSTEM_CAPTURE_INST_VIP0_PORTA+i;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].numChInDevice    = 4;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoIfMode        = DEVICE_CAPT_VIDEO_IF_MODE_8BIT;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoDataFormat    = SYSTEM_DF_YUV422P;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.standard           = SYSTEM_STD_MUX_4CH_D1;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoCaptureMode   =
                        DEVICE_CAPT_VIDEO_CAPTURE_MODE_MULTI_CH_PIXEL_MUX_EMBEDDED_SYNC;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoSystem        =
                                          DEVICE_VIDEO_DECODER_VIDEO_SYSTEM_AUTO_DETECT;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoCropEnable    = FALSE;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoAutoDetectTimeout = -1;
        }
        else
        {
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].deviceId         = SYSTEM_DEVICE_VID_DEC_SII9135_DRV;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].vipInstId        = SYSTEM_CAPTURE_INST_VIP0_PORTA+i;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].numChInDevice    = 1;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoIfMode        = DEVICE_CAPT_VIDEO_IF_MODE_16BIT;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoDataFormat    = SYSTEM_DF_YUV422P;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.standard           = SYSTEM_STD_1080P_60;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoCaptureMode   =
                                    DEVICE_CAPT_VIDEO_CAPTURE_MODE_SINGLE_CH_NON_MUX_DISCRETE_SYNC_HSYNC_VSYNC;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoSystem        =
                                    DEVICE_VIDEO_DECODER_VIDEO_SYSTEM_AUTO_DETECT;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoCropEnable    = FALSE;
            gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[i].modeParams.videoAutoDetectTimeout = -1;
        }
    }
    Vcap_configVideoDecoder(&gHDSDIDVRUsecaseContext.vidDecVideoModeArgs[0],
                            numCaptureDevices);
    Vcap_getVideoSourceStatus(&vidSourceStatus);
    Vcap_setVideoSourceStatus(&vidSourceStatus);
}


static
Void multich_hdsdidvr_set_dei_prm(DeiLink_CreateParams *deiPrm)
{
    int deiChIdx;

    deiPrm->numBufsPerCh[DEI_LINK_OUT_QUE_VIP_SC] = NUM_BUFS_PER_CH_DEI_VIP_SC_PRIQ;

    deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].scaleMode = DEI_SCALE_MODE_RATIO;
    deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.heightRatio.numerator = 1;
    deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.heightRatio.denominator = 1;
    deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.widthRatio.numerator = 1;
    deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0].ratio.widthRatio.denominator = 1;
    for (deiChIdx = 1; deiChIdx < DEI_LINK_MAX_CH; deiChIdx++)
    {
        deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][deiChIdx] =
            deiPrm->outScaleFactor[DEI_LINK_OUT_QUE_VIP_SC][0];
    }
    deiPrm->enableOut[DEI_LINK_OUT_QUE_DEI_SC]                        = FALSE;
    deiPrm->enableOut[DEI_LINK_OUT_QUE_VIP_SC]                        = TRUE;
    deiPrm->enableOut[DEI_LINK_OUT_QUE_VIP_SC_SECONDARY_OUT]          = FALSE;
    deiPrm->enableOut[DEI_LINK_OUT_QUE_DEI_SC_SECONDARY_OUT]          = FALSE;
    deiPrm->enableOut[DEI_LINK_OUT_QUE_DEI_SC_TERTIARY_OUT]           = FALSE;
    deiPrm->tilerEnable[DEI_LINK_OUT_QUE_VIP_SC]          = TILER_ENABLE_ENCODE;
    deiPrm->comprEnable                                   = FALSE;
    deiPrm->setVipScYuv422Format                          = FALSE;
    deiPrm->enableInputFrameRateUpscale                   = FALSE;
}

static
Void multich_hdsdidvr_set_enclink_prm(EncLink_CreateParams *encPrm)
{
    int i;
    EncLink_ChCreateParams *pLinkChPrm;
    EncLink_ChDynamicParams *pLinkDynPrm;
    VENC_CHN_DYNAMIC_PARAM_S *pDynPrm;
    VENC_CHN_PARAMS_S *pChPrm;

    encPrm->numBufPerCh[ENC_LINK_PRIMARY_STREAM_POOL_ID] = NUM_BUFS_PER_CH_ENC_PRI;
    /* Primary Stream Params - D1 */
    for (i=0; i < gVencModuleContext.vencConfig.numPrimaryChn; i++)
    {
        pLinkChPrm  = &encPrm->chCreateParams[i];
        pLinkDynPrm = &pLinkChPrm->defaultDynamicParams;

        pChPrm      = &gVencModuleContext.vencConfig.encChannelParams[i];
        pDynPrm     = &pChPrm->dynamicParam;

        pLinkChPrm->format                  = IVIDEO_H264HP;
        pLinkChPrm->profile                 = gVencModuleContext.vencConfig.h264Profile[i];
        pLinkChPrm->dataLayout              = IVIDEO_FIELD_SEPARATED;
        pLinkChPrm->fieldMergeEncodeEnable  = FALSE;
        pLinkChPrm->enableAnalyticinfo      = pChPrm->enableAnalyticinfo;
        pLinkChPrm->maxBitRate              = pChPrm->maxBitRate;
        pLinkChPrm->encodingPreset          = pChPrm->encodingPreset;
        pLinkChPrm->rateControlPreset       = pChPrm->rcType;
        pLinkChPrm->enableHighSpeed         = FALSE;
        pLinkChPrm->numTemporalLayer        = VENC_TEMPORAL_LAYERS_1;
        pLinkChPrm->enableSVCExtensionFlag  = pChPrm->enableSVCExtensionFlag;

        pLinkDynPrm->intraFrameInterval     = pDynPrm->intraFrameInterval;
        pLinkDynPrm->targetBitRate          = pDynPrm->targetBitRate;
        pLinkDynPrm->interFrameInterval     = 1;
        pLinkDynPrm->mvAccuracy             = IVIDENC2_MOTIONVECTOR_QUARTERPEL;
        pLinkDynPrm->inputFrameRate         = pDynPrm->inputFrameRate;
        pLinkDynPrm->rcAlg                  = pDynPrm->rcAlg;
        pLinkDynPrm->qpMin                  = pDynPrm->qpMin;
        pLinkDynPrm->qpMax                  = pDynPrm->qpMax;
        pLinkDynPrm->qpInit                 = pDynPrm->qpInit;
        pLinkDynPrm->vbrDuration            = pDynPrm->vbrDuration;
        pLinkDynPrm->vbrSensitivity         = pDynPrm->vbrSensitivity;
    }

}


static
Void multich_hdsdidvr_set_swms_prm(SwMsLink_CreateParams *swMsPrm,
                                    UInt32 swMsIdx)
{
    UInt32 devId;

    swMsPrm->numSwMsInst = 1;
    swMsPrm->swMsInstId[0] = SYSTEM_SW_MS_SC_INST_SC5;
    swMsPrm->maxInputQueLen            = SYSTEM_SW_MS_DEFAULT_INPUT_QUE_LEN + 6;
    swMsPrm->numOutBuf = NUM_BUFS_PER_CH_SWMS_HD;
    swMsPrm->enableProcessTieWithDisplay = TRUE;
    swMsPrm->enableOuputDup = TRUE;
    swMsPrm->outDataFormat  = SYSTEM_DF_YUV422I_YUYV;
    swMsPrm->maxOutRes  = VSYS_STD_1080P_60;
    if (0 == swMsIdx)
    {
        devId               = VDIS_DEV_HDMI;
    }
    else
    {
        devId               = VDIS_DEV_DVO2;
    }
    swMsPrm->initOutRes = gVdisModuleContext.vdisConfig.deviceParams[VDIS_DEV_HDMI].resolution;
    swMsPrm->numOutBuf  = NUM_BUFS_PER_CH_SWMS_HD;
    swMsPrm->lineSkipMode = FALSE;
    swMsPrm->enableLayoutGridDraw = gVdisModuleContext.vdisConfig.enableLayoutGridDraw;
}

static
Void mulich_hdsdidvr_set_avsync_vidque_prm(Avsync_SynchConfigParams *queCfg,
                                            Int chnum,
                                            UInt32 avsStartChNum,
                                            UInt32 avsEndChNum)
{
    queCfg->chNum = chnum;
    queCfg->audioPresent = FALSE;
    if ((queCfg->chNum >= avsStartChNum)
        &&
        (queCfg->chNum <= avsEndChNum)
        &&
        (gVsysModuleContext.vsysConfig.enableAVsync))
    {
        queCfg->avsyncEnable = FALSE;
    }
    else
    {
        queCfg->avsyncEnable = FALSE;
    }
    queCfg->clkAdjustPolicy.refClkType = AVSYNC_REFCLKADJUST_NONE;
    queCfg->playTimerStartTimeout = 0;
    queCfg->playStartMode = AVSYNC_PLAYBACK_START_MODE_WAITSYNCH;
    queCfg->ptsInitMode   = AVSYNC_PTS_INIT_MODE_APP;
    queCfg->clkAdjustPolicy.clkAdjustLead = AVSYNC_VIDEO_TIMEBASESHIFT_MAX_LEAD_MS;
    queCfg->clkAdjustPolicy.clkAdjustLag = AVSYNC_VIDEO_TIMEBASESHIFT_MAX_LAG_MS;
    queCfg->vidSynchPolicy.playMaxLag    = 200;
}

static
Void mulich_hdsdidvr_set_avsync_prm(AvsyncLink_LinkSynchConfigParams *avsyncPrm,
                                     UInt32 swMsIdx,
                                     UInt32 prevLinkID,
                                     UInt32 prevLinkQueId)
{
    System_LinkInfo                   swmsInLinkInfo;
    Int i;
    Int32 status;

    if (0 == swMsIdx)
    {
        Vdis_getAvsyncConfig(VDIS_DEV_HDMI,avsyncPrm);
        avsyncPrm->displayLinkID        = Vdis_getDisplayId(VDIS_DEV_HDMI);
        avsyncPrm->videoSynchLinkID = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)];
    }
    else
    {
        Vdis_getAvsyncConfig(VDIS_DEV_SD,avsyncPrm);
        avsyncPrm->displayLinkID        = Vdis_getDisplayId(VDIS_DEV_SD);
        avsyncPrm->videoSynchLinkID = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_SD)];
    }
    System_linkGetInfo(prevLinkID,&swmsInLinkInfo);
    OSA_assert(swmsInLinkInfo.numQue > prevLinkQueId);

    avsyncPrm->numCh            = swmsInLinkInfo.queInfo[prevLinkQueId].numCh;
    avsyncPrm->syncMasterChnum = AVSYNC_INVALID_CHNUM;
    for (i = 0; i < avsyncPrm->numCh;i++)
    {
        mulich_hdsdidvr_set_avsync_vidque_prm(&avsyncPrm->queCfg[i],
                                               i,
                                               gVcapModuleContext.vcapConfig.numChn,
                                               (gVcapModuleContext.vcapConfig.numChn + (gVdecModuleContext.vdecConfig.numChn - 1)));
    }
    if (0 == swMsIdx)
    {
        Vdis_setAvsyncConfig(VDIS_DEV_HDMI,avsyncPrm);
    }
    else
    {
        Vdis_setAvsyncConfig(VDIS_DEV_DVO2,avsyncPrm);
    }

    status = Avsync_configSyncConfigInfo(avsyncPrm);
    OSA_assert(status == 0);

}


static
Void multich_hdsdidvr_set_declink_prms(DecLink_CreateParams *decPrm)
{
    int i;


    gVdecModuleContext.vdecConfig.numChn = (NUM_SD_DECODE_CHANNELS + NUM_HD_DECODE_CHANNELS);
    for (i=0; i<gVdecModuleContext.vdecConfig.numChn; i++)
    {
        decPrm->chCreateParams[i].format                 = IVIDEO_H264HP;
        decPrm->chCreateParams[i].profile                = IH264VDEC_PROFILE_ANY;
        decPrm->chCreateParams[i].processCallLevel       = VDEC_FRAMELEVELPROCESSCALL;
        if (i < NUM_SD_DECODE_CHANNELS)
        {
            decPrm->chCreateParams[i].targetMaxWidth         = SD_DECODE_CHANNEL_WIDTH;
            decPrm->chCreateParams[i].targetMaxHeight        = SD_DECODE_CHANNEL_HEIGHT;
            decPrm->chCreateParams[i].numBufPerCh            = NUM_BUFS_PER_CH_DEC_SD;
            decPrm->chCreateParams[i].tilerEnable = TILER_ENABLE_DECODE_SD;
        }
        else
        {
            decPrm->chCreateParams[i].targetMaxWidth         = HD_DECODE_CHANNEL_WIDTH;
            decPrm->chCreateParams[i].targetMaxHeight        = HD_DECODE_CHANNEL_HEIGHT;
            decPrm->chCreateParams[i].numBufPerCh            = NUM_BUFS_PER_CH_DEC_HD;
            decPrm->chCreateParams[i].tilerEnable = TILER_ENABLE_DECODE_HD;
        }
        decPrm->chCreateParams[i].defaultDynamicParams.targetFrameRate = gVdecModuleContext.vdecConfig.decChannelParams[i].dynamicParam.frameRate;
        decPrm->chCreateParams[i].defaultDynamicParams.targetBitRate   = gVdecModuleContext.vdecConfig.decChannelParams[i].dynamicParam.targetBitRate;
    }
}

static
Void multich_hdsdidvr_set_ipcbitsout_hlos_prms(IpcBitsOutLinkHLOS_CreateParams * ipcBitsOutHostPrm)
{
    int i;

    for (i = 0;
         i < (NUM_SD_DECODE_CHANNELS + NUM_HD_DECODE_CHANNELS);
         i++)
    {
        System_LinkChInfo *pChInfo;

        pChInfo = &ipcBitsOutHostPrm->inQueInfo.chInfo[i];

        pChInfo->bufType        = 0; // NOT USED
        pChInfo->codingformat   = 0; // NOT USED
        pChInfo->dataFormat     = 0; // NOT USED
        pChInfo->memType        = 0; // NOT USED
        pChInfo->startX         = 0; // NOT USED
        pChInfo->startY         = 0; // NOT USED
        if (i < NUM_SD_DECODE_CHANNELS)
        {
            pChInfo->width          = SD_DECODE_CHANNEL_WIDTH;
            pChInfo->height         = SD_DECODE_CHANNEL_HEIGHT;
        }
        else
        {
            pChInfo->width          = HD_DECODE_CHANNEL_WIDTH;
            pChInfo->height         = HD_DECODE_CHANNEL_HEIGHT;
        }
        pChInfo->pitch[0]       = 0; // NOT USED
        pChInfo->pitch[1]       = 0; // NOT USED
        pChInfo->pitch[2]       = 0; // NOT USED
        pChInfo->scanFormat     = SYSTEM_SF_PROGRESSIVE;
    }
    ipcBitsOutHostPrm->baseCreateParams.noNotifyMode = FALSE;
    ipcBitsOutHostPrm->baseCreateParams.notifyNextLink = TRUE;
    ipcBitsOutHostPrm->baseCreateParams.numOutQue = 1;
    ipcBitsOutHostPrm->numBufPerCh[IPCBITSOUT_LINK_SD_STREAM_POOL_ID] =
        NUM_BUFS_PER_CH_BITSOUT_SD;
    ipcBitsOutHostPrm->numBufPerCh[IPCBITSOUT_LINK_HD_STREAM_POOL_ID] =
        NUM_BUFS_PER_CH_BITSOUT_HD;
    ipcBitsOutHostPrm->inQueInfo.numCh =
        (NUM_SD_DECODE_CHANNELS + NUM_HD_DECODE_CHANNELS);
}

static
Void multich_hdsdidvr_set_display_prms(DisplayLink_CreateParams *displayPrm,
                                        UInt32 maxOutRes)
{
    displayPrm->displayRes = maxOutRes;
}

static
Void multich_hdsdidvr_set_link_ids()
{
    int    i;

    gVcapModuleContext.captureId    = SYSTEM_LINK_ID_CAPTURE;

    gVcapModuleContext.deiId[0]     = SYSTEM_LINK_ID_DEI_HQ_0;
    for (i = 0; i < NUM_MERGE_LINK;i++)
    {
        gHDSDIDVRUsecaseContext.mergeId[i] = SYSTEM_VPSS_LINK_ID_MERGE_0 + i;
    }
    for (i = 0; i < NUM_DUP_LINK;i++)
    {
        gHDSDIDVRUsecaseContext.dupId[i] = SYSTEM_VPSS_LINK_ID_DUP_0 + i;
    }

    gVencModuleContext.encId        = SYSTEM_LINK_ID_VENC_0;
    gVdecModuleContext.decId        = SYSTEM_LINK_ID_VDEC_0;

    gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)]      = SYSTEM_LINK_ID_SW_MS_MULTI_INST_0;
    gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)]      = SYSTEM_LINK_ID_SW_MS_MULTI_INST_1;

    gVdisModuleContext.displayId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)] = SYSTEM_LINK_ID_DISPLAY_0; /* ON CHIP HDMI */
    gVdisModuleContext.displayId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)] = SYSTEM_LINK_ID_DISPLAY_1; /* SD HDMI */

    gHDSDIDVRUsecaseContext.ipcOutVpssId = SYSTEM_VPSS_LINK_ID_IPC_OUT_M3_0;
    gHDSDIDVRUsecaseContext.ipcInVideoId = SYSTEM_VIDEO_LINK_ID_IPC_IN_M3_0;
    gHDSDIDVRUsecaseContext.ipcOutVideoId= SYSTEM_VIDEO_LINK_ID_IPC_OUT_M3_0;
    gHDSDIDVRUsecaseContext.ipcInVpssId  = SYSTEM_VPSS_LINK_ID_IPC_IN_M3_0;

    gVencModuleContext.ipcBitsOutRTOSId  = SYSTEM_VIDEO_LINK_ID_IPC_BITS_OUT_0;
    gVencModuleContext.ipcBitsInHLOSId   = SYSTEM_HOST_LINK_ID_IPC_BITS_IN_0;
    gVdecModuleContext.ipcBitsOutHLOSId  = SYSTEM_HOST_LINK_ID_IPC_BITS_OUT_0;
    gVdecModuleContext.ipcBitsInRTOSId  = SYSTEM_VIDEO_LINK_ID_IPC_BITS_IN_0;
    gVdisModuleContext.setMosaicFxn     = MultiCh_hdsdiDVRSetMosaicParams;
}

static
Void multich_hdsdidvr_reset_link_ids()
{
    int    i;

    gVcapModuleContext.captureId    = SYSTEM_LINK_ID_INVALID;

    gVcapModuleContext.deiId[0]     = SYSTEM_LINK_ID_INVALID;
    for (i = 0; i < NUM_MERGE_LINK;i++)
    {
        gHDSDIDVRUsecaseContext.mergeId[i] = SYSTEM_LINK_ID_INVALID;
    }
    for (i = 0; i < NUM_DUP_LINK;i++)
    {
        gHDSDIDVRUsecaseContext.dupId[i] = SYSTEM_LINK_ID_INVALID;
    }

    gVencModuleContext.encId        = SYSTEM_LINK_ID_INVALID;
    gVdecModuleContext.decId        = SYSTEM_LINK_ID_INVALID;

    gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)]      = SYSTEM_LINK_ID_INVALID;
    gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)]      = SYSTEM_LINK_ID_INVALID;

    gVdisModuleContext.displayId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)] = SYSTEM_LINK_ID_INVALID; /* ON CHIP HDMI */
    gVdisModuleContext.displayId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)] = SYSTEM_LINK_ID_INVALID; /* SD HDMI */

    gHDSDIDVRUsecaseContext.ipcOutVpssId = SYSTEM_LINK_ID_INVALID;
    gHDSDIDVRUsecaseContext.ipcInVideoId = SYSTEM_LINK_ID_INVALID;
    gHDSDIDVRUsecaseContext.ipcOutVideoId= SYSTEM_LINK_ID_INVALID;
    gHDSDIDVRUsecaseContext.ipcInVpssId  = SYSTEM_LINK_ID_INVALID;

    gVencModuleContext.ipcBitsOutRTOSId  = SYSTEM_LINK_ID_INVALID;
    gVencModuleContext.ipcBitsInHLOSId   = SYSTEM_LINK_ID_INVALID;
    gVdecModuleContext.ipcBitsOutHLOSId  = SYSTEM_LINK_ID_INVALID;
    gVdecModuleContext.ipcBitsInRTOSId  = SYSTEM_LINK_ID_INVALID;
    gVdisModuleContext.setMosaicFxn     = NULL;
}

static
Void multich_hdsdidvr_set_capture_fps(UInt32 *captureFps)
{
    Bool isPal = Vcap_isPalMode();

    if (isPal)
    {
        *captureFps = 50;
    }
    else
    {
        *captureFps = 60;
    }
}


static
Void multich_hdsdidvr_set_links_framerate()
{
    Int32 status;
    DeiLink_ChFpsParams params;
    UInt32 chId;
    Bool isPAL = Vcap_isPalMode();
    Bool fieldRateUpscale = FALSE;

    for (chId = 0; chId < gVcapModuleContext.vcapConfig.numChn;chId++)
    {
        /* Capture -> Dei */
        params.chId = chId;

        /* Stream 0 -VIP_SC_OUT_PRIMARY is inputfps/2 */
        params.streamId = DEI_LINK_OUT_QUE_VIP_SC;
        if (isPAL && fieldRateUpscale)
        {
            /* Input is 30 even for PAL because we do field repeat at DEI input */
            params.inputFrameRate  = 30;
        }
        else
        {
            params.inputFrameRate  = MULTICH_HDSDIDVR_GET_CAPTURE_FRAMES_PER_SEC();
        }

        params.outputFrameRate = MULTICH_HDSDIDVR_GET_CAPTURE_FRAMES_PER_SEC();
        status = System_linkControl(gVcapModuleContext.deiId[0], DEI_LINK_CMD_SET_FRAME_RATE,
                                    &params, sizeof(params), TRUE);
    }
}

static
Void multich_hdsdidvr_connect_links()
{
     multich_hdsdidvr_configure_extvideodecoder_prm();
      /**Capture Link**/
     multich_hdsdidvr_set_capture_prm(&gHDSDIDVRUsecaseContext.capturePrm);
     /* Capture ---Q0---> Dei */
     gHDSDIDVRUsecaseContext.capturePrm.outQueParams[0].nextLink   = gVcapModuleContext.deiId[0];
     gHDSDIDVRUsecaseContext.deiPrm[0].inQueParams.prevLinkId      = gVcapModuleContext.captureId;
     gHDSDIDVRUsecaseContext.deiPrm[0].inQueParams.prevLinkQueId   = 0;
     /* Capture ---Q1---> Merge */
     gHDSDIDVRUsecaseContext.capturePrm.outQueParams[1].nextLink   = gHDSDIDVRUsecaseContext.mergeId[PRE_ENCODE_MERGE_LINK_IDX];
     gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].numInQue                      = PRE_ENCODE_MERGE_LINK_NUM_INQUE;
     gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].inQueParams[PRE_ENCODE_MERGE_LINK_HDCAPTURE_QIDX].prevLinkId      = gVcapModuleContext.captureId;
     gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].inQueParams[PRE_ENCODE_MERGE_LINK_HDCAPTURE_QIDX].prevLinkQueId   = 1;
     MULTICH_HDSDIDVR_CREATE_LINK(gVcapModuleContext.captureId,&gHDSDIDVRUsecaseContext.capturePrm,sizeof(gHDSDIDVRUsecaseContext.capturePrm));
     /**After Capture is created set capture fps */
     multich_hdsdidvr_set_capture_fps(&gHDSDIDVRUsecaseContext.captureFps);

     /**Dei0 Link**/
     multich_hdsdidvr_set_dei_prm(&gHDSDIDVRUsecaseContext.deiPrm[0]);
     /* DEI(0) ---DEI_VIP_SC_D1_MERGE_LINK_IDX--- mergeId[PRE_ENCODE_MERGE_LINK_IDX] */
     gHDSDIDVRUsecaseContext.deiPrm[0].outQueParams[DEI_LINK_OUT_QUE_VIP_SC].nextLink  =  gHDSDIDVRUsecaseContext.mergeId[PRE_ENCODE_MERGE_LINK_IDX];
     gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].numInQue                      = PRE_ENCODE_MERGE_LINK_NUM_INQUE;
     gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].inQueParams[PRE_ENCODE_MERGE_LINK_DEI0_D1_QIDX].prevLinkId     = gVcapModuleContext.deiId[0];
     gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].inQueParams[PRE_ENCODE_MERGE_LINK_DEI0_D1_QIDX].prevLinkQueId  = 0;
     MULTICH_HDSDIDVR_CREATE_LINK(gVcapModuleContext.deiId[0],&gHDSDIDVRUsecaseContext.deiPrm[0],sizeof(gHDSDIDVRUsecaseContext.deiPrm[0]));

    /** mergeId[PRE_ENCODE_MERGE_LINK_IDX] **/
    gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].numInQue   = PRE_ENCODE_MERGE_LINK_NUM_INQUE;
    /* mergeId[PRE_ENCODE_MERGE_LINK_IDX] ---Q0---> ipcOutVpssM3 */
    gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].outQueParams.nextLink    = gHDSDIDVRUsecaseContext.ipcOutVpssId;
    gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX].notifyNextLink           = TRUE;
    gHDSDIDVRUsecaseContext.ipcOutVpssPrm.inQueParams.prevLinkId         = gHDSDIDVRUsecaseContext.mergeId[PRE_ENCODE_MERGE_LINK_IDX];
    gHDSDIDVRUsecaseContext.ipcOutVpssPrm.inQueParams.prevLinkQueId      = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gHDSDIDVRUsecaseContext.mergeId[PRE_ENCODE_MERGE_LINK_IDX],
                                  &gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX],
                                  sizeof(gHDSDIDVRUsecaseContext.mergePrm[PRE_ENCODE_MERGE_LINK_IDX]));

    /* ipcOutVpssIdisOutVpssId ---Q0---> ipcInVideoId */
    gHDSDIDVRUsecaseContext.ipcOutVpssPrm.outQueParams[0].nextLink  = gHDSDIDVRUsecaseContext.ipcInVideoId;
    gHDSDIDVRUsecaseContext.ipcOutVpssPrm.notifyNextLink            = FALSE;
    gHDSDIDVRUsecaseContext.ipcOutVpssPrm.notifyPrevLink            = TRUE;
    gHDSDIDVRUsecaseContext.ipcOutVpssPrm.noNotifyMode              = TRUE;
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.inQueParams.prevLinkId    = gHDSDIDVRUsecaseContext.ipcOutVpssId;
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gHDSDIDVRUsecaseContext.ipcOutVpssId,
                                  &gHDSDIDVRUsecaseContext.ipcOutVpssPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcOutVpssPrm));


    /* ipcInVideoId ---Q0---> encId */
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.numOutQue                 = 1;
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.outQueParams[0].nextLink  = gVencModuleContext.encId;
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.notifyNextLink            = TRUE;
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.notifyPrevLink            = FALSE;
    gHDSDIDVRUsecaseContext.ipcInVideoPrm.noNotifyMode              = TRUE;
    gHDSDIDVRUsecaseContext.encPrm.inQueParams.prevLinkId    = gHDSDIDVRUsecaseContext.ipcInVideoId;
    gHDSDIDVRUsecaseContext.encPrm.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gHDSDIDVRUsecaseContext.ipcInVideoId,
                                  &gHDSDIDVRUsecaseContext.ipcInVideoPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcInVideoPrm));


    /* encId ---Q0---> ipcBitsOutRTOSId */
    multich_hdsdidvr_set_enclink_prm(&gHDSDIDVRUsecaseContext.encPrm);
    gHDSDIDVRUsecaseContext.encPrm.outQueParams.nextLink     = gVencModuleContext.ipcBitsOutRTOSId;
    gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkId = gVencModuleContext.encId;
    gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm.baseCreateParams.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gVencModuleContext.encId,
                                  &gHDSDIDVRUsecaseContext.encPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.encPrm));

    /* ipcBitsOutVideoId ---Q0---> ipcBitsInHostId */
    gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm.baseCreateParams.numOutQue                 = 1;
    gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm.baseCreateParams.outQueParams[0].nextLink = gVencModuleContext.ipcBitsInHLOSId;
    MultiCh_ipcBitsInitCreateParams_BitsOutRTOS(&gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm,
                                               TRUE);
    gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[0].baseCreateParams.inQueParams.prevLinkId = gVencModuleContext.ipcBitsOutRTOSId;
    gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[0].baseCreateParams.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gVencModuleContext.ipcBitsOutRTOSId,
                                  &gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcBitsOutVideoPrm));
    MultiCh_ipcBitsInitCreateParams_BitsInHLOS(&gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[0]);
    MULTICH_HDSDIDVR_CREATE_LINK(gVencModuleContext.ipcBitsInHLOSId,
                                  &gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[0],
                                  sizeof(gHDSDIDVRUsecaseContext.ipcBitsInHostPrm[0]));

    /* ipcBitsOutHostId ---Q0---> ipcBitsInRtosId */
    multich_hdsdidvr_set_ipcbitsout_hlos_prms(&gHDSDIDVRUsecaseContext.ipcBitsOutHostPrm);
    gHDSDIDVRUsecaseContext.ipcBitsOutHostPrm.baseCreateParams.outQueParams[0].nextLink = gVdecModuleContext.ipcBitsInRTOSId;
    gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm.baseCreateParams.inQueParams.prevLinkId       = gVdecModuleContext.ipcBitsOutHLOSId;
    gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm.baseCreateParams.inQueParams.prevLinkQueId    = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gVdecModuleContext.ipcBitsOutHLOSId,
                                  &gHDSDIDVRUsecaseContext.ipcBitsOutHostPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcBitsOutHostPrm));

    /* ipcBitsInRtosId ---Q0---> decId */
    gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm.baseCreateParams.numOutQue                    = 1;
    gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm.baseCreateParams.outQueParams[0].nextLink     = gVdecModuleContext.decId;
    MultiCh_ipcBitsInitCreateParams_BitsInRTOS(&gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm, TRUE);
    gHDSDIDVRUsecaseContext.decPrm.inQueParams.prevLinkId    = gVdecModuleContext.ipcBitsInRTOSId;
    gHDSDIDVRUsecaseContext.decPrm.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gVdecModuleContext.ipcBitsInRTOSId,
                                  &gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcBitsInVideoPrm));

    /* decId---Q0--->ipcOutVideoId*/
    multich_hdsdidvr_set_declink_prms(&gHDSDIDVRUsecaseContext.decPrm);
    gHDSDIDVRUsecaseContext.decPrm.outQueParams.nextLink  = gHDSDIDVRUsecaseContext.ipcOutVideoId;
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.inQueParams.prevLinkId    = gVdecModuleContext.decId;
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gVdecModuleContext.decId,
                                  &gHDSDIDVRUsecaseContext.decPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.decPrm));

    /*ipcOutVideoId---Q0-->ipcInVpssId*/
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.numOutQue                 = 1;
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.outQueParams[0].nextLink  = gHDSDIDVRUsecaseContext.ipcInVpssId;
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.notifyNextLink            = FALSE;
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.notifyPrevLink            = TRUE;
    gHDSDIDVRUsecaseContext.ipcOutVideoPrm.noNotifyMode              = TRUE;
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.inQueParams.prevLinkId    = gHDSDIDVRUsecaseContext.ipcOutVideoId;
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gHDSDIDVRUsecaseContext.ipcOutVideoId,
                                  &gHDSDIDVRUsecaseContext.ipcOutVideoPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcOutVideoPrm));

    /*ipcInVpssId---Q0--> mergeId[LIVE_DECODE_MERGE_LINK_IDX] */
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.numOutQue                 = 1;
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.outQueParams[0].nextLink  = gHDSDIDVRUsecaseContext.dupId[DECODE_DUP_LINK_IDX];
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.notifyNextLink            = TRUE;
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.notifyPrevLink            = FALSE;
    gHDSDIDVRUsecaseContext.ipcInVpssPrm.noNotifyMode              = TRUE;
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].inQueParams.prevLinkId = gHDSDIDVRUsecaseContext.ipcInVpssId;
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].inQueParams.prevLinkQueId = 0;
    MULTICH_HDSDIDVR_CREATE_LINK(gHDSDIDVRUsecaseContext.ipcInVpssId,
                                  &gHDSDIDVRUsecaseContext.ipcInVpssPrm,
                                  sizeof(gHDSDIDVRUsecaseContext.ipcInVpssPrm));

    /*dupId[DECODE_DUP_LINK_IDX]---Q0--> swMsId[0] */
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].numOutQue                      = 2;
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].outQueParams[0].nextLink       = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)];
    gHDSDIDVRUsecaseContext.swMsPrm[0].inQueParams.prevLinkId    = gHDSDIDVRUsecaseContext.dupId[DECODE_DUP_LINK_IDX];
    gHDSDIDVRUsecaseContext.swMsPrm[0].inQueParams.prevLinkQueId = 0;

    /*dupId[LIVE_DECODE_DUP_LINK_IDX]---Q1--> swMsId[1] */
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].numOutQue                      = 2;
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].outQueParams[1].nextLink       = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)];
    gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX].notifyNextLink                 = TRUE;
    gHDSDIDVRUsecaseContext.swMsPrm[1].inQueParams.prevLinkId    = gHDSDIDVRUsecaseContext.dupId[DECODE_DUP_LINK_IDX];
    gHDSDIDVRUsecaseContext.swMsPrm[1].inQueParams.prevLinkQueId = 1;
    MULTICH_HDSDIDVR_CREATE_LINK(gHDSDIDVRUsecaseContext.dupId[DECODE_DUP_LINK_IDX],
                                  &gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX],
                                  sizeof(gHDSDIDVRUsecaseContext.dupPrm[DECODE_DUP_LINK_IDX]));

    /* Avsync configuration for SwMs[0] */
    mulich_hdsdidvr_set_avsync_prm(&gHDSDIDVRUsecaseContext.avsyncCfg[0],
                                    0,
                                    gHDSDIDVRUsecaseContext.dupId[DECODE_DUP_LINK_IDX],
                                    0);
    /*swMsId[0]---Q0--> displayId[VDIS_DEV_HDMI] */
    gHDSDIDVRUsecaseContext.swMsPrm[0].outQueParams.nextLink     = Vdis_getDisplayId(VDIS_DEV_HDMI);
    gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)].numInputQueues = 1;
    gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)].inQueParams[0].prevLinkId    = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)];
    gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)].inQueParams[0].prevLinkQueId = 0;
    multich_hdsdidvr_set_swms_prm(&gHDSDIDVRUsecaseContext.swMsPrm[0],
                                    0);
    gHDSDIDVRUsecaseContext.swmsLayoutPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)] = gHDSDIDVRUsecaseContext.swMsPrm[0].layoutPrm;
    MULTICH_HDSDIDVR_CREATE_LINK(gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)],
                                 &gHDSDIDVRUsecaseContext.swMsPrm[0],
                                 sizeof(gHDSDIDVRUsecaseContext.swMsPrm[0]));

    /* Avsync configuration for SwMs[1] */
    mulich_hdsdidvr_set_avsync_prm(&gHDSDIDVRUsecaseContext.avsyncCfg[1],
                                    1,
                                    gHDSDIDVRUsecaseContext.dupId[DECODE_DUP_LINK_IDX],
                                    1);
    /*swMsId[1]---Q1--> displayId[VDIS_DEV_SD] */
    gHDSDIDVRUsecaseContext.swMsPrm[1].outQueParams.nextLink     = Vdis_getDisplayId(VDIS_DEV_DVO2);
    gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)].numInputQueues = 1;
    gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)].inQueParams[0].prevLinkId    = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)];
    gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)].inQueParams[0].prevLinkQueId = 0;
    multich_hdsdidvr_set_swms_prm(&gHDSDIDVRUsecaseContext.swMsPrm[1],
                                    1);
    gHDSDIDVRUsecaseContext.swmsLayoutPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)] = gHDSDIDVRUsecaseContext.swMsPrm[1].layoutPrm;
    MULTICH_HDSDIDVR_CREATE_LINK(gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)],
                                  &gHDSDIDVRUsecaseContext.swMsPrm[1],
                                  sizeof(gHDSDIDVRUsecaseContext.swMsPrm[1]));

    multich_hdsdidvr_set_display_prms(&gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)],
                                        gHDSDIDVRUsecaseContext.swMsPrm[0].initOutRes);
    MULTICH_HDSDIDVR_CREATE_LINK(Vdis_getDisplayId(VDIS_DEV_HDMI),
                                  &gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)],
                                  sizeof(gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_HDMI)]));
    multich_hdsdidvr_set_display_prms(&gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)],
                                        gHDSDIDVRUsecaseContext.swMsPrm[1].initOutRes);
    MULTICH_HDSDIDVR_CREATE_LINK(Vdis_getDisplayId(VDIS_DEV_DVO2),
                                  &gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)],
                                  sizeof(gHDSDIDVRUsecaseContext.displayPrm[Vdis_getDisplayContextIndex(VDIS_DEV_DVO2)]));
}

static
void multich_hdsdidvr_set_dec2disp_chmap()
{

    MultiCh_setDec2DispMap(VDIS_DEV_HDMI,gVdecModuleContext.vdecConfig.numChn,0,0);
    MultiCh_setDec2DispMap(VDIS_DEV_DVO2,gVdecModuleContext.vdecConfig.numChn,0,0);
}


Void MultiCh_createHDSDIDVR()
{

    multich_hdsdidvr_reset_link_prms();
    multich_hdsdidvr_set_link_ids();
    printf("\n********* Entered usecase HDSDIDVR <816x> Cap/Enc/Dec/Dis \n\n");

    MultiCh_detectBoard();

    System_linkControl(
        SYSTEM_LINK_ID_M3VPSS,
        SYSTEM_M3VPSS_CMD_RESET_VIDEO_DEVICES,
        NULL,
        0,
        TRUE
        );

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

    if ((FALSE == TILER_ENABLE_ENCODE) && (FALSE == TILER_ENABLE_DECODE_SD) && (FALSE == TILER_ENABLE_DECODE_HD))
    {
        SystemTiler_disableAllocator();
    }
    multich_hdsdidvr_connect_links();
    multich_hdsdidvr_set_links_framerate();
    multich_hdsdidvr_set_dec2disp_chmap();
    Vdis_getMosaicParams(VDIS_DEV_HDMI,&gHDSDIDVRUsecaseContext.vdisMosaicPrms[VDIS_DEV_HDMI]);
    Vdis_getMosaicParams(VDIS_DEV_DVO2,&gHDSDIDVRUsecaseContext.vdisMosaicPrms[VDIS_DEV_DVO2]);
    Vdis_setMosaicParams(VDIS_DEV_HDMI,&gHDSDIDVRUsecaseContext.vdisMosaicPrms[VDIS_DEV_HDMI]);
    Vdis_setMosaicParams(VDIS_DEV_DVO2,&gHDSDIDVRUsecaseContext.vdisMosaicPrms[VDIS_DEV_DVO2]);

}

Void MultiCh_deleteHDSDIDVR()
{
    UInt32 i;

    for (i = 0; i < gHDSDIDVRUsecaseContext.createdLinkCount; i++)
    {
        System_linkDelete (gHDSDIDVRUsecaseContext.createdLinks[i]);
    }
    gHDSDIDVRUsecaseContext.createdLinkCount = 0;
    multich_hdsdidvr_reset_link_ids();

    Vcap_deleteVideoDecoder();
    /* Print the HWI, SWI and all tasks load */
    /* Reset the accumulated timer ticks */
    MultiCh_prfLoadCalcEnable(FALSE, TRUE, FALSE);

    if ((FALSE == TILER_ENABLE_ENCODE) && (FALSE == TILER_ENABLE_DECODE_SD) && (FALSE == TILER_ENABLE_DECODE_HD))
    {
        SystemTiler_enableAllocator();
    }
}

static
UInt32 multich_hdsdidvr_map_swms_channel2win(VDIS_DEV devId,UInt32 swMsChNum)
{
    UInt32 winNum = SYSTEM_SW_MS_INVALID_ID;
    Int i;

    for (i = 0; i < gHDSDIDVRUsecaseContext.swmsLayoutPrm[Vdis_getDisplayContextIndex(devId)].numWin;i++)
    {
        if (swMsChNum == gHDSDIDVRUsecaseContext.swmsLayoutPrm[Vdis_getDisplayContextIndex(devId)].winInfo[i].channelNum)
        {
            winNum = i;
            break;
        }
    }
    return winNum;
}

static
Bool  multich_hdsdidvr_is_invisible_channel(VDIS_DEV devId,UInt32 swMsChNum)
{
    if (multich_hdsdidvr_map_swms_channel2win(devId, swMsChNum) == SYSTEM_SW_MS_INVALID_ID)
    {
        return TRUE;
    }
    else
    {
        return FALSE;
    }
}



static
Void  multich_hdsdidvr_get_decode_visibility_channels_list(UInt32 *invisbleChannelList,
                                                           UInt32 *numInvisibleCh,UInt32 maxInvisibleCh,
                                                           UInt32 *visbleChannelList,
                                                           UInt32 *numVisibleCh,UInt32 maxVisibleCh)
{
    Int i;
    UInt32 swmsChNum;
    UInt32 swmsChNumSD;

    *numInvisibleCh = 0;

    for (i = 0; i < gVdecModuleContext.vdecConfig.numChn ;i++)
    {
        Vdec_mapDec2DisplayChId(VDIS_DEV_HDMI,i,&swmsChNum);
        Vdec_mapDec2DisplayChId(VDIS_DEV_SD,i,&swmsChNumSD);
        OSA_assert(swmsChNum == swmsChNumSD);
        if (multich_hdsdidvr_is_invisible_channel(VDIS_DEV_HDMI,swmsChNum)
            &&
            multich_hdsdidvr_is_invisible_channel(VDIS_DEV_SD,swmsChNum))
        {
            OSA_assert(*numInvisibleCh < maxInvisibleCh);
            invisbleChannelList[*numInvisibleCh] = i;
            *numInvisibleCh += 1;
        }
        else
        {
            OSA_assert(*numVisibleCh < maxVisibleCh);
            visbleChannelList[*numVisibleCh] = i;
            *numVisibleCh += 1;
        }
    }
}

static
Void  multich_hdsdidvr_enable_visible_decode_channels()
{
    Int i;
    UInt32 numInvisibleCh = 0;
    UInt32 numVisibleCh = 0;
    DecLink_ChannelInfo decChInfo;
    Int32 status;

    multich_hdsdidvr_get_decode_visibility_channels_list(gHDSDIDVRUsecaseContext.invisbleDecChannelList,
                                                          &numInvisibleCh,
                                                          OSA_ARRAYSIZE(gHDSDIDVRUsecaseContext.invisbleDecChannelList),
                                                          gHDSDIDVRUsecaseContext.visbleDecChannelList,
                                                          &numVisibleCh,
                                                          OSA_ARRAYSIZE(gHDSDIDVRUsecaseContext.visbleDecChannelList));
    for (i =0; i < numVisibleCh;i++)
    {
        decChInfo.chId     = gHDSDIDVRUsecaseContext.visbleDecChannelList[i];
        printf("MULTICH_HDSDI_DVR:Decode enable visible channel.DEC_LINKID[0x%X],CHNUM[%d]\n",
                gVdecModuleContext.decId,decChInfo.chId);
        status =
        System_linkControl(gVdecModuleContext.decId,DEC_LINK_CMD_ENABLE_CHANNEL,
                            &decChInfo,sizeof(decChInfo),TRUE);
        OSA_assert(status == 0);
    }

    for (i =0; i < numInvisibleCh;i++)
    {
        decChInfo.chId     = gHDSDIDVRUsecaseContext.invisbleDecChannelList[i];
        printf("MULTICH_HDSDI_DVR:Decode disable invisible channel.DEC_LINKID[0x%X],CHNUM[%d]\n",
                gVdecModuleContext.decId,decChInfo.chId);
        status =
        System_linkControl(gVdecModuleContext.decId,DEC_LINK_CMD_DISABLE_CHANNEL,
                            &decChInfo,sizeof(decChInfo),TRUE);
        OSA_assert(status == 0);
    }
}

static
Int32 MultiCh_hdsdiDVRSetMosaicParams(VDIS_DEV vdDevId, VDIS_MOSAIC_S *psVdMosaicParam )
{
    UInt32 winId, chId;
    UInt32 swMsId = SYSTEM_LINK_ID_INVALID;
    SwMsLink_LayoutPrm *vdisLayoutPrm;

    swMsId = gVdisModuleContext.swMsId[Vdis_getDisplayContextIndex(vdDevId)];
    if(swMsId==SYSTEM_LINK_ID_INVALID)
        return -1;

    vdisLayoutPrm = &gHDSDIDVRUsecaseContext.swmsLayoutPrm[Vdis_getDisplayContextIndex(vdDevId)];

    /* Get display resolution and coordinates */
    vdisLayoutPrm->numWin = psVdMosaicParam->numberOfWindows;
    vdisLayoutPrm->onlyCh2WinMapChanged = psVdMosaicParam->onlyCh2WinMapChanged;
    vdisLayoutPrm->outputFPS = psVdMosaicParam->outputFPS;

    /* Assign each windows coordinates, size and mapping */
    for(winId=0; winId<vdisLayoutPrm->numWin; winId++)
    {
        vdisLayoutPrm->winInfo[winId].channelNum         = psVdMosaicParam->chnMap[winId];
        vdisLayoutPrm->winInfo[winId].bufAddrOffset[0u]      = -1;
        vdisLayoutPrm->winInfo[winId].bufAddrOffset[1u]      = -1;
        vdisLayoutPrm->winInfo[winId].width              = psVdMosaicParam->winList[winId].width;
        vdisLayoutPrm->winInfo[winId].height             = psVdMosaicParam->winList[winId].height;
        vdisLayoutPrm->winInfo[winId].startX             = psVdMosaicParam->winList[winId].start_X;
        vdisLayoutPrm->winInfo[winId].startY             = psVdMosaicParam->winList[winId].start_Y;
        vdisLayoutPrm->winInfo[winId].bypass             = FALSE;
        chId = psVdMosaicParam->chnMap[winId];

        if(chId < gVdisModuleContext.vdisConfig.numChannels)
        {
            Vdis_setChn2WinMap(vdDevId, chId,winId);

            if(Vdis_isEnableChn(vdDevId,chId) == FALSE)
            {
                vdisLayoutPrm->winInfo[winId].channelNum = SYSTEM_SW_MS_INVALID_ID;
            }
        }
    }

    Vdis_swMs_PrintLayoutParams(vdDevId, vdisLayoutPrm);
    System_linkControl(swMsId, SYSTEM_SW_MS_LINK_CMD_SWITCH_LAYOUT, (vdisLayoutPrm), sizeof(*vdisLayoutPrm), TRUE);

    multich_hdsdidvr_enable_visible_decode_channels();
    return 0;
}