a strange problem about sw

/**
  \file demo_vcap_venc_vdec_vdis.c
  \brief
  */
#include <sys/time.h>
#include <demo_vcap_venc_vdec_vdis.h>
#include <demo_scd_bits_wr.h>

/* Setting secondary out <CIF> for 30 frames - this is the validated frame rate;
any higher number will impact performance. */

#ifdef TI_816X_BUILD
#define     CIF_FPS_ENC_NTSC         (30)
#define     CIF_FPS_ENC_PAL          (25)
#endif
#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
#define     CIF_FPS_ENC_NTSC         (30)
#define     CIF_FPS_ENC_PAL          (25)
#endif
#define     CIF_BITRATE         (500)
#define     MJPEG_BITRATE       (100)



static Int64 get_current_time_to_msec(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);

    return ((Int64)tv.tv_sec*1000 + tv.tv_usec/1000);
}

/* used in 814x 16ch usecase */
#define H264_PRIMARY_STREAM_PROFILE     VENC_CHN_MAIN_PROFILE
#define H264_SECONDARY_STREAM_PROFILE   VENC_CHN_BASELINE_PROFILE

/* used to set resolution / buf size of ipcbits for varying resolutions based on usecase */
VcapVencVdecVdis_chBufInfo ipcBitsChInfo[MCFW_IPCBITS_MAX_CHANNELS];
static Bool audioEnabled = FALSE;

Void VcapVencVdecVdis_setFileWriteMask(Int32 systemUseCase)
{
    if(systemUseCase == VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_D1_AND_CIF)
    {
        if (((MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_DEFAULT) & (MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_CHANNEL_0_CHANNEL_1_CHANNEL16))
                != (MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_CHANNEL_0_CHANNEL_1_CHANNEL16))
        {
            VcapVencVdecVdis_ipcBitsSetFileWriteMask(MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_CHANNEL_0_CHANNEL_1_CHANNEL16);
        }
    }
    else if (systemUseCase == VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_16CH_NRT)
    {
        if (((MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_DEFAULT) & (MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_CHANNEL_0_CHANNEL16))
                != (MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_CHANNEL_0_CHANNEL16))
        {
            VcapVencVdecVdis_ipcBitsSetFileWriteMask(MCFW_IPC_BITS_FWRITE_ENABLE_BITMASK_CHANNEL_0_CHANNEL16);
        }
    }
}

Void VcapVencVdecVdis_setEncParans(VENC_PARAMS_S *pVencParams, VSYS_PARAMS_S *pVsysParams)
{
#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
    Int32 i;

    if(pVsysParams->systemUseCase == VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_D1_AND_CIF
        || pVsysParams->systemUseCase == VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_16CH_NRT)
    {
        for (i=0; i < VENC_PRIMARY_CHANNELS; i++)
        {
            pVencParams->h264Profile[i] = H264_PRIMARY_STREAM_PROFILE;
        }
        for (i=VENC_PRIMARY_CHANNELS; i < (2*VENC_PRIMARY_CHANNELS); i++)
        {
            pVencParams->h264Profile[i] = H264_SECONDARY_STREAM_PROFILE;
        }
        /* QCIF channels */
        for (i=VENC_PRIMARY_CHANNELS; i < (2*VENC_PRIMARY_CHANNELS); i++)
        {
            pVencParams->encChannelParams[i].dynamicParam.targetBitRate = .2 * 1000 * 1000;
        }
    }
    if(pVsysParams->systemUseCase == VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_D1_AND_CIF)
    {
        pVencParams->encChannelParams[0].dynamicParam.targetBitRate = 2 * 1000 * 1000;
        /* CIF channels */
        for (i=1; i < VENC_PRIMARY_CHANNELS; i++)
        {
            pVencParams->encChannelParams[i].dynamicParam.targetBitRate = .5 * 1000 * 1000;
        }
    }
#ifdef TI_8107_BUILD
    if (pVsysParams->systemUseCase == VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_D1_AND_CIF)
    {
        for (i = 0; i < 2*VENC_PRIMARY_CHANNELS; i++)
        {
            /*This is an optimization option used for the 810X 16CH CIF DVR usecase*/
            pVencParams->encChannelParams[i].numTemporalLayer = VENC_TEMPORAL_LAYERS_2;
        }
    }
#endif
#endif
}

Void VcapVencVdecVdis_setChannels(int demoId, int *pEnable2ndOut)
{
    Int32 i;

    memset(ipcBitsChInfo, 0, sizeof(ipcBitsChInfo));

    switch (demoId)
    {
        case    DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE:

          /*  gDemo_info.maxVcapChannels = 16;
            gDemo_info.maxVdisChannels = 32;
            gDemo_info.maxVencChannels = 16;
            gDemo_info.maxVdecChannels = 16;
            gDemo_info.VsysNumChs  = 16;
            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                ipcBitsChInfo[i].width = MCFW_IPCBITS_D1_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_D1_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }
            break; */
            gDemo_info.maxVcapChannels = 2; //4;
            gDemo_info.maxVdisChannels = 4; //8;
            gDemo_info.maxVencChannels = 2; //4;
            gDemo_info.maxVdecChannels = 2; //4;
            gDemo_info.VsysNumChs      = 2; //4;

            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                ipcBitsChInfo[i].width = MCFW_IPCBITS_HD_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_HD_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }
            break;

        case    DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_NON_D1:
        case    DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_16CH_NRT:
            gDemo_info.maxVcapChannels = 16;
            gDemo_info.maxVdisChannels = 32;
            gDemo_info.maxVencChannels = 16;
            gDemo_info.maxVdecChannels = 16;
            gDemo_info.VsysNumChs  = 16;

            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                /* Retaining max resolution ignoring CIF */
                ipcBitsChInfo[i].width = MCFW_IPCBITS_D1_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_D1_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }
            break;

        case DEMO_VCAP_VENC_VDIS_HD:
            gDemo_info.maxVcapChannels = 2; //4;
            gDemo_info.maxVdisChannels = 4; //8;
            gDemo_info.maxVencChannels = 2; //4;
            gDemo_info.maxVdecChannels = 2; //4;
            gDemo_info.VsysNumChs      = 2; //4;

            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                ipcBitsChInfo[i].width = MCFW_IPCBITS_HD_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_HD_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }
            break;

        case    DEMO_VCAP_VENC_VDEC_VDIS_INTERLACED:
#ifdef TI_816X_BUILD
            gDemo_info.maxVcapChannels = 16;
            gDemo_info.maxVdisChannels = 32;
            gDemo_info.maxVencChannels = 16;
            gDemo_info.maxVdecChannels = 16;
            gDemo_info.VsysNumChs  = 16;
#endif
            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                ipcBitsChInfo[i].width = MCFW_IPCBITS_D1_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_D1_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }

            break;
        case    DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_4CH:
            gDemo_info.maxVcapChannels = 4;
            gDemo_info.maxVdisChannels = 8;
            gDemo_info.maxVencChannels = 4;
            gDemo_info.maxVdecChannels = 4;
            gDemo_info.VsysNumChs  = 4;

            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                ipcBitsChInfo[i].width = MCFW_IPCBITS_D1_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_D1_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }
            break;

        case    DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH:
        case    DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH_NRT:
            gDemo_info.maxVcapChannels = 8;
            gDemo_info.maxVdisChannels = 16;
            gDemo_info.maxVencChannels = 8;
            gDemo_info.maxVdecChannels = 8;
            gDemo_info.VsysNumChs  = 8;

            for(i=0; i<gDemo_info.maxVdecChannels; i++)
            {
                ipcBitsChInfo[i].width = MCFW_IPCBITS_D1_WIDTH;
                ipcBitsChInfo[i].height = MCFW_IPCBITS_D1_HEIGHT;
                ipcBitsChInfo[i].chBufSize = ipcBitsChInfo[i].width * ipcBitsChInfo[i].height;
            }
            break;

        default:
            break;
    }
}


Void Demo_disableMJPEG ()
{
    int i;

    for (i = 32; i < 48; i++)
    {
        Venc_disableChn (i);
    }
}

int Demo_startAudio(int demoId)
{
    audioEnabled = FALSE;
#ifndef SYSTEM_DISABLE_AUDIO
#ifndef TI8107_BCH_120_DVR
    if (DEMO_HYBRIDDVR_16CH != demoId)
    {
        char ch;

        printf("\r\n\n AUDIO: Do you enable Audio <Y/N>: ");
        ch = Demo_getChar();
        if (ch == 'y' || ch == 'Y')
        {
            audioEnabled = TRUE;
            printf ("\r\n\n\n\n -------- Starting Audio Capture ----------\n\n");
            Demo_startStopAudioEncodeDecode(demoId, DEMO_AUDIO_TYPE_CAPTURE, TRUE);
        }
    }
#endif
#endif
    return 0;
}

Void VcapVencVdecVdis_start( Bool doProgressiveVenc, Bool enableSecondaryOut, int demoId)
{
    UInt32 i, resolutionClass; //scdStartChId;
    VSYS_PARAMS_S vsysParams;
    VCAP_PARAMS_S vcapParams;
    VENC_PARAMS_S vencParams;
    VDEC_PARAMS_S vdecParams;
    VDIS_PARAMS_S vdisParams;
    Bool forceLowCostScale = FALSE, enableFWrite = FALSE, enableLayerWrite = FALSE;
    /**/
    enableSecondaryOut = FALSE;
    /**/
    Int32 Enable2ndOut = enableSecondaryOut;
   // VENC_CHN_DYNAMIC_PARAM_S params = { 0 };
    UInt32 chId;
    UInt16 osdFormat[ALG_LINK_OSD_MAX_CH];
    UInt64 wallTimeBase;

    Vsys_params_init(&vsysParams);
    Vcap_params_init(&vcapParams);
    Venc_params_init(&vencParams);
    Vdec_params_init(&vdecParams);
    Vdis_params_init(&vdisParams);

    VcapVencVdecVdis_setChannels(demoId, &Enable2ndOut);


    vcapParams.numChn = gDemo_info.maxVcapChannels;
    vencParams.numPrimaryChn = gDemo_info.maxVencChannels;
    vencParams.numSecondaryChn = 0;
    vdecParams.numChn = gDemo_info.maxVdecChannels;
    vdisParams.numChannels = gDemo_info.maxVdisChannels;
    vsysParams.numChs  = gDemo_info.VsysNumChs;

    enableSecondaryOut = (Bool)Enable2ndOut;

    /* Most of progressive use cases have OSD in YUV420 SP format */
    for(chId = 0; chId < ALG_LINK_OSD_MAX_CH; chId++)
         osdFormat[chId] = SYSTEM_DF_YUV420SP_UV;

        vsysParams.osdFormat = FALSE;


    vsysParams.systemUseCase = VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC;


    resolutionClass = DEMO_SCD_RESOLUTION_CLASS_CIF;


            vsysParams.enableSecondaryOut = FALSE;
            vsysParams.enableNsf     = TRUE; //FALSE;



        vsysParams.enableCapture = TRUE;
        vsysParams.enableNullSrc = FALSE;

        vsysParams.enableOsd     = FALSE; //TRUE;


        vsysParams.enableScd     = FALSE; //TRUE;
        vsysParams.numDeis       = 2;
        vsysParams.numSwMs       = 2;
        vsysParams.numDisplays   = 3;
        vsysParams.enableAVsync  = TRUE; //TRUE;



    printf ("--------------- CHANNEL DETAILS-------------\n");
    printf ("Capture Channels => %d\n", vcapParams.numChn);
    printf ("Disp Channels => %d\n", vdisParams.numChannels);
    printf ("-------------------------------------------\n");

    Vsys_enableFastUsecaseSwitch(FALSE);

    /* Override the context here as needed */
    Vsys_init(&vsysParams);

    /* Override the context here as needed */
    Vcap_init(&vcapParams);



    /* Override the context here as needed */
    vdisParams.deviceParams[VDIS_DEV_HDMI].resolution   =  DEMO_HD_DISPLAY_DEFAULT_STD;
    vdisParams.deviceParams[VDIS_DEV_DVO2].resolution = DEMO_HD_DISPLAY_DEFAULT_STD;
    vdisParams.deviceParams[VDIS_DEV_HDCOMP].resolution = DEMO_HD_DISPLAY_DEFAULT_STD;

    vdisParams.mosaicLayoutResolution[VDIS_DEV_HDMI] =
        vdisParams.deviceParams[VDIS_DEV_HDMI].resolution;
    vdisParams.mosaicLayoutResolution[VDIS_DEV_DVO2] =
        vdisParams.deviceParams[VDIS_DEV_DVO2].resolution;
    vdisParams.mosaicLayoutResolution[VDIS_DEV_HDCOMP] =
        vdisParams.deviceParams[VDIS_DEV_HDCOMP].resolution;

    Vdis_tiedVencInit(VDIS_DEV_DVO2, VDIS_DEV_HDCOMP, &vdisParams);

    vdisParams.deviceParams[VDIS_DEV_SD].resolution     = VSYS_STD_NTSC;
    vdisParams.mosaicLayoutResolution[VDIS_DEV_SD] =
        vdisParams.deviceParams[VDIS_DEV_SD].resolution;

    vdisParams.enableLayoutGridDraw = FALSE;

    {
        /* set for 3 displays */

        i = 0;
        Demo_swMsGenerateLayout(VDIS_DEV_HDMI, 0, gDemo_info.maxVdisChannels,
                              /*DEMO_LAYOUT_MODE_16CH*/DEMO_LAYOUT_MODE_1CH,
                              &vdisParams.mosaicParams[i], forceLowCostScale,
                              gDemo_info.Type,
                              Vdis_getSwMsLayoutResolution(VDIS_DEV_HDMI));
        vdisParams.mosaicParams[i].userSetDefaultSWMLayout = TRUE;
        vdisParams.mosaicParams[i].outputFPS = 60;


        if (vsysParams.systemUseCase != VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_4CH)
        {
            i = 1;
            Demo_swMsGenerateLayout(VDIS_DEV_DVO2, 16, gDemo_info.maxVdisChannels,
            		 /*DEMO_LAYOUT_MODE_16CH*/DEMO_LAYOUT_MODE_1CH,
                                  &vdisParams.mosaicParams[i], forceLowCostScale,
                                  gDemo_info.Type,
                                  Vdis_getSwMsLayoutResolution(VDIS_DEV_DVO2));
            vdisParams.mosaicParams[i].userSetDefaultSWMLayout = TRUE;
            vdisParams.mosaicParams[i].outputFPS = 60;
        }
        if (vsysParams.systemUseCase != VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_4CH)
            i = 2;
        else
            i = 1;

    }

    vdisParams.enableConfigExtThsFilter    = FALSE;
    vdisParams.enableConfigExtVideoEncoder = FALSE;

    Vdis_init(&vdisParams);

    enableFWrite = FALSE;

    /*h264 Enc: Needs to be checked for any channel where this flag is enabled,
         * right now just checking for channel 0, default value for other codecs is 0*/
    if(vencParams.encChannelParams[0].numTemporalLayer > 1)
        enableLayerWrite = TRUE;


    wallTimeBase = get_current_time_to_msec();
    //wallTimeBase = 0;
    Vdis_setWallTimeBase(wallTimeBase);

    /* Configure display in order to start grpx before video */
    Vsys_configureDisplay();

    /* Create Link instances and connects compoent blocks */
    Vsys_create();

    /* Start components in reverse order */
    Vdis_start();
    Vcap_start();

    Vsys_printDetailedStatistics();
}



Void VcapVencVdecVdis_stop()
{
    VSYS_PARAMS_S contextInf;
    Vsys_getContext(&contextInf);

    Vsys_enableFastUsecaseSwitch(FALSE);

    printf("++++++++ VcapVencVdecVdis_stop()\n");

    /* Stop components */

    VcapVencVdecVdis_ipcBitsStop();

    Vcap_stop();
    Venc_stop();
    Vdec_stop();
    Vdis_stop();


#if USE_FBDEV
     grpx_exit();
#endif

     /* Free the osd buffers */
    Demo_osdDeinit();
    if(contextInf.enableScd)
        Scd_bitsWriteStop();

    Vsys_delete();

    Vsys_deConfigureDisplay();

    if(contextInf.enableScd)
        Scd_bitsWriteDelete();


    VcapVencVdecVdis_ipcBitsExit();

    /* De-initialize components */
    Vcap_exit();
    Venc_exit();
    Vdec_exit();
    Vdis_exit();

    Vsys_exit();

}

#if defined(TI_814X_BUILD) || defined(TI_8107_BUILD)
int Demo_change8ChMode(int demoId)
{
    int value;
    int chId;

    VENC_CHN_DYNAMIC_PARAM_S params_venc = { 0 };
    VCAP_CHN_DYNAMIC_PARAM_S params_vcap = { 0 };


    if (demoId != DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH &&
        demoId != DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH_NRT)
    {
        printf("This function is valid ONLY for DM814X and DM810X 8CH usecase!!!!!\n");
        return 0;
    }

    value = Demo_getIntValue("Select Mode(0:2D1+6CIF, 1:8 2CIF, 2:8D1 non-realtime, 3:8HalfD1, 4:8D1)", 0, 4, 0);

    /*HACK HACK set secondary enc fps to 1fps */
    #ifndef DDR_MEM_256M
    memset(&params_venc, 0, sizeof(params_venc));
    params_venc.frameRate = Vcap_isPalMode() ? 25 : 30;
    for (chId = 8; chId < 16; chId++)
    {
        Venc_setInputFrameRate(chId, Vcap_isPalMode() ? 25 : 30);
        Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
    }
    #else //defined DDR_MEM_256M
    memset(&params_venc, 0, sizeof(params_venc));
    params_venc.frameRate = 2;
    params_venc.targetBitRate = 50 * 1000;
    for (chId = 8; chId < 16; chId++)
    {
        Venc_setInputFrameRate(chId, 2);
        Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
    }
    #endif
    switch (value)
    {
    case 0:
        memset(&params_vcap, 0, sizeof(params_vcap));
        memset(&params_venc, 0, sizeof(params_venc));
        params_venc.frameRate = 30;
        for (chId = 0; chId < 8; chId++)
        {
            Venc_setInputFrameRate(chId, Vcap_isPalMode() ? 25 : 30);
            Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
        }
        params_vcap.chDynamicRes.pathId = 1;
        params_vcap.chDynamicRes.width  = 704;
        params_vcap.chDynamicRes.height = Vcap_isPalMode() ? 576 : 480;
        Vcap_setDynamicParamChn(0, &params_vcap, VCAP_RESOLUTION);
        Vcap_setDynamicParamChn(4, &params_vcap, VCAP_RESOLUTION);

        params_vcap.chDynamicRes.width  = 352;
        params_vcap.chDynamicRes.height = Vcap_isPalMode() ? 288 : 240;
        Vcap_setDynamicParamChn(1, &params_vcap, VCAP_RESOLUTION);
        Vcap_setDynamicParamChn(2, &params_vcap, VCAP_RESOLUTION);
        Vcap_setDynamicParamChn(3, &params_vcap, VCAP_RESOLUTION);
        Vcap_setDynamicParamChn(5, &params_vcap, VCAP_RESOLUTION);
        Vcap_setDynamicParamChn(6, &params_vcap, VCAP_RESOLUTION);
        Vcap_setDynamicParamChn(7, &params_vcap, VCAP_RESOLUTION);

        demoId = DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH;

        break;
    case 1:
        memset(&params_vcap, 0, sizeof(params_vcap));
        memset(&params_venc, 0, sizeof(params_venc));
        params_vcap.chDynamicRes.pathId = 1;
        params_vcap.chDynamicRes.width  = 704;
        params_vcap.chDynamicRes.height = Vcap_isPalMode() ? 288 : 240;
        params_venc.frameRate = Vcap_isPalMode() ? 25 : 30;
        for (chId = 0; chId < 8; chId++)
        {
            Vcap_setDynamicParamChn(chId, &params_vcap, VCAP_RESOLUTION);
            Venc_setInputFrameRate(chId, Vcap_isPalMode() ? 25 : 30);
            Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
        }
        demoId = DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH;
        break;
    case 2:
        memset(&params_vcap, 0, sizeof(params_vcap));
        memset(&params_venc, 0, sizeof(params_venc));
        params_vcap.chDynamicRes.pathId = 1;
        params_vcap.chDynamicRes.width  = 704;
        params_vcap.chDynamicRes.height = Vcap_isPalMode() ? 576 : 480;
        params_venc.frameRate = Vcap_isPalMode() ? 12 : 15;
        for (chId = 0; chId < 8; chId++)
        {
            Vcap_setDynamicParamChn(chId, &params_vcap, VCAP_RESOLUTION);
            Venc_setInputFrameRate(chId, Vcap_isPalMode() ? 25 : 30);
            Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
        }
        break;
    case 3:
        memset(&params_vcap, 0, sizeof(params_vcap));
        memset(&params_venc, 0, sizeof(params_venc));
        params_vcap.chDynamicRes.pathId = 1;
        params_vcap.chDynamicRes.width  = 352;
        params_vcap.chDynamicRes.height = Vcap_isPalMode() ? 576 : 480;
        params_venc.frameRate = Vcap_isPalMode() ? 25 : 30;
        for (chId = 0; chId < 8; chId++)
        {
            Vcap_setDynamicParamChn(chId, &params_vcap, VCAP_RESOLUTION);
            Venc_setInputFrameRate(chId, Vcap_isPalMode() ? 25 : 30);
            Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
        }
        demoId = DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_8CH;
        break;
    case 4:
        memset(&params_vcap, 0, sizeof(params_vcap));
        memset(&params_venc, 0, sizeof(params_venc));
        params_vcap.chDynamicRes.pathId = 1;
        params_vcap.chDynamicRes.width  = 704;
        params_vcap.chDynamicRes.height = Vcap_isPalMode() ? 576 : 480;
        params_venc.frameRate = Vcap_isPalMode() ? 25 : 30;
        for (chId = 0; chId < 8; chId++)
        {
            Vcap_setDynamicParamChn(chId, &params_vcap, VCAP_RESOLUTION);
            Venc_setInputFrameRate(chId, Vcap_isPalMode() ? 25 : 30);
            Venc_setDynamicParam(chId, 0, &params_venc, VENC_FRAMERATE);
        }
        break;
    default:
        break;
    }

    return demoId;
}



int Demo_change16ChSwitchUsecase(int userInputValue)
{
    VSYS_PARAMS_S contextInf;
    VSYS_PARAMS_S vsysParams;
    VCAP_PARAMS_S vcapParams;
    VENC_PARAMS_S vencParams;
    VDEC_PARAMS_S vdecParams;
    VDIS_PARAMS_S vdisParams;
    Bool forceLowCostScale = FALSE, enableFWrite = FALSE, enableLayerWrite = FALSE;
    UInt32 chId, resolutionClass;
    UInt16 osdFormat[ALG_LINK_OSD_MAX_CH];
    UInt32 demoId;
    Int32 Enable2ndOut = FALSE;

    /*******************************
                     Stop usecase
         ******************************/
    Vsys_getContext(&contextInf);

    /* Stop components */
    Vcap_stop();
    Venc_stop();
    Vdec_stop();
    Vdis_stop();

    /* Free the osd buffers */
    Demo_osdDeinit();

    /* skip some de-init to allow fast use-case switch */
    Vsys_enableFastUsecaseSwitch(TRUE);

    Vsys_delete();

    if(contextInf.enableScd)
        Scd_bitsWriteDelete();

    VcapVencVdecVdis_ipcBitsExit();

    /* De-initialize components */
    Vcap_exit();
    Venc_exit();
    Vdec_exit();
    Vdis_exit();
    Vsys_exit();

    /*******************************
                     Start usecase
     ******************************/
    Vsys_params_init(&vsysParams);
    Vcap_params_init(&vcapParams);
    Venc_params_init(&vencParams);
    Vdec_params_init(&vdecParams);
    Vdis_params_init(&vdisParams);

    vcapParams.numChn          = 16;
    vencParams.numPrimaryChn   = 16;
    vencParams.numSecondaryChn = 16;
    vdecParams.numChn          = 16;
    vdisParams.numChannels     = 32;
    vsysParams.numChs          = 16;

    /* Most of progressive use cases have OSD in YUV420 SP format */
    for(chId = 0; chId < ALG_LINK_OSD_MAX_CH; chId++)
         osdFormat[chId] = SYSTEM_DF_YUV420SP_UV;

    /* Set the demo Id which is going to start */
    if (userInputValue == 1)
    {
        vsysParams.systemUseCase = VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_16CH_NRT;
        demoId = DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_16CH_NRT;
    }
    else
    {
        vsysParams.systemUseCase = VSYS_USECASE_MULTICHN_PROGRESSIVE_VCAP_VDIS_VENC_VDEC_D1_AND_CIF;
        demoId = DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_NON_D1;
    }

    VcapVencVdecVdis_setChannels(demoId, &Enable2ndOut);


    vsysParams.enableSecondaryOut = TRUE;
    vsysParams.enableNsf          = TRUE;
    vsysParams.enableMjpegEnc     = TRUE;
    vsysParams.enableCapture      = TRUE;
    vsysParams.enableNullSrc      = FALSE;

    vsysParams.enableOsd          = TRUE;
    vsysParams.enableScd          = FALSE;

    vsysParams.numDeis            = 1;
    vsysParams.numSwMs            = 2;
    vsysParams.numDisplays        = 2;
    vsysParams.enableAVsync       = TRUE;

    /* Override the context here as needed */
    Vsys_init(&vsysParams);

    /* Do reinit which doesnt uninit tvp5158 handles */
#if     0
    /* Override the context here as needed */
    Vcap_init(&vcapParams);
#else
    /* Override the context here as needed */
    Vcap_reInit(&vcapParams);
#endif

    /*Enabling generation of motion vector for channel 0 only,
         * for other channels please add to the below line*/

    vencParams.encChannelParams[0].enableAnalyticinfo = 1;
    vencParams.encChannelParams[0].maxBitRate = -1;
    VcapVencVdecVdis_setEncParans(&vencParams,&vsysParams);

    /* Override the context here as needed */
    Venc_init(&vencParams);

    /* Override the context here as needed */
    Vdec_init(&vdecParams);

    /* Override the context here as needed */
    vdisParams.deviceParams[VDIS_DEV_HDMI].resolution   = DEMO_HD_DISPLAY_DEFAULT_STD;
    vdisParams.deviceParams[VDIS_DEV_HDCOMP].resolution = DEMO_HD_DISPLAY_DEFAULT_STD;
    vdisParams.mosaicLayoutResolution[VDIS_DEV_HDMI] =
        vdisParams.deviceParams[VDIS_DEV_HDMI].resolution;
    vdisParams.mosaicLayoutResolution[VDIS_DEV_DVO2] =
        vdisParams.deviceParams[VDIS_DEV_DVO2].resolution;
    Vdis_tiedVencInit(VDIS_DEV_HDCOMP, VDIS_DEV_DVO2, &vdisParams);

    vdisParams.deviceParams[VDIS_DEV_SD].resolution     = VSYS_STD_NTSC;
    vdisParams.mosaicLayoutResolution[VDIS_DEV_SD] =
        vdisParams.deviceParams[VDIS_DEV_SD].resolution;
    vdisParams.enableLayoutGridDraw = FALSE;

    /* set for 2 displays */
    Demo_swMsGenerateLayout(VDIS_DEV_HDMI, 0, vdisParams.numChannels,
                          DEMO_LAYOUT_MODE_7CH_1CH,
                          &vdisParams.mosaicParams[VDIS_DEV_HDMI], forceLowCostScale,
                          DEMO_TYPE_PROGRESSIVE,
                          Vdis_getSwMsLayoutResolution(VDIS_DEV_HDMI));
    vdisParams.mosaicParams[VDIS_DEV_HDMI].userSetDefaultSWMLayout = TRUE;
    Demo_swMsGenerateLayout(VDIS_DEV_SD, 0, vdisParams.numChannels,
                          DEMO_LAYOUT_MODE_7CH_1CH,
                          &vdisParams.mosaicParams[VDIS_DEV_SD], forceLowCostScale,
                          DEMO_TYPE_PROGRESSIVE,
                          Vdis_getSwMsLayoutResolution(VDIS_DEV_SD));
    vdisParams.mosaicParams[VDIS_DEV_SD].userSetDefaultSWMLayout = TRUE;

    Vdis_init(&vdisParams);

    resolutionClass = DEMO_SCD_RESOLUTION_CLASS_QCIF;

    if(vsysParams.enableScd == TRUE)
    {
        Scd_bitsWriteCreate(demoId, resolutionClass);
    }

    enableFWrite = FALSE;//Demo_getFileWriteEnable();
    if(vencParams.encChannelParams[0].numTemporalLayer > 1)
        enableLayerWrite = TRUE;

    /* Init the application specific module which will handle bitstream exchange */
    VcapVencVdecVdis_ipcBitsInit(ipcBitsChInfo, enableFWrite,enableLayerWrite);

    /* Create Link instances and connects compoent blocks */

    /* skip some init to allow fast use-case switch */
    Vsys_enableFastUsecaseSwitch(TRUE);

    Vsys_create();

    /* reset flag so that normal use-case exit free all resources */
    Vsys_enableFastUsecaseSwitch(FALSE);

    if(vsysParams.enableOsd)
    {
        gDemo_info.osdEnable = TRUE;

        /* Create and initialize OSD window buffers */
        Demo_osdInit(gDemo_info.maxVencChannels, osdFormat);

        for(chId = 0; chId < gDemo_info.maxVencChannels; chId++)
        {
            vcapParams.channelParams[chId].dynamicParams.osdChWinPrm = &g_osdChParam[chId];
            /* Initailize osdLink with created and set win params */
            Vcap_setDynamicParamChn(chId, &vcapParams.channelParams[chId].dynamicParams, VCAP_OSDWINPRM);
        }
    }

    /* Start components in reverse order */
    Vdis_start();
    Vdec_start();
    Venc_start();
    Vcap_start();

    return 0;
}

/* Only for TI_814X and TI_8107 16ch usecases
    Switch working mode between 16ch CIF realtime mode and 16ch D1 non-realtime mode */
int Demo_change16ChMode(int demoId)
{
    UInt32 value;

    if ((demoId != DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_NON_D1) &&
       (demoId != DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_16CH_NRT))
    {
        printf("This function is ONLY valid for TI_814X or TI_8107 16CH usecase!!!!!\n");
        return 0;
    }

    value = Demo_getIntValue("Select Mode(0:16Ch realtime, 1:16D1 non-realtime, 2:Switch Continously)", 0, 2, 0);

    if(value==0)
        Demo_change16ChSwitchUsecase(value);
    if(value==1)
        Demo_change16ChSwitchUsecase(value);
    if(value==2)
    {
        int loop=10000, i;

        for(i=0; i<loop; i++)
        {
            printf(" ###\n");
            printf(" ###\n");
            printf(" ### Starting Iteration %d of %d\n", i, loop);
            printf(" ###\n");
            printf(" ### Switching to 16Ch real-time\n");
            printf(" ###\n");
            Demo_change16ChSwitchUsecase(0);
            OSA_waitMsecs(15*1000);
            Demo_printInfo(DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_NON_D1);
            OSA_waitMsecs(1*1000);
            printf(" ###\n");
            printf(" ### Switching to 16D1 Non real-time\n");
            printf(" ###\n");
            Demo_change16ChSwitchUsecase(1);
            OSA_waitMsecs(15*1000);
            Demo_printInfo(DEMO_VCAP_VENC_VDEC_VDIS_PROGRESSIVE_16CH_NRT);
            OSA_waitMsecs(1*1000);
            printf(" ###\n");
            printf(" ### Completed Iteration %d of %d\n", i, loop);
            printf(" ###\n");
            printf(" ###\n");
        }
    }

    return 0;
}
#endif