RTOS: TDA2px:ISS camera capture display usecase error

/******************************************************************************
Copyright (c) [2012 - 2017] Texas Instruments Incorporated

All rights reserved not granted herein.

Limited License.

 Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
 license under copyrights and patents it now or hereafter owns or controls to
 make,  have made, use, import, offer to sell and sell ("Utilize") this software
 subject to the terms herein.  With respect to the foregoing patent license,
 such license is granted  solely to the extent that any such patent is necessary
 to Utilize the software alone.  The patent license shall not apply to any
 combinations which include this software, other than combinations with devices
 manufactured by or for TI ("TI Devices").  No hardware patent is licensed
 hereunder.

 Redistributions must preserve existing copyright notices and reproduce this
 license (including the above copyright notice and the disclaimer and
 (if applicable) source code license limitations below) in the documentation
 and/or other materials provided with the distribution

 Redistribution and use in binary form, without modification, are permitted
 provided that the following conditions are met:

 * No reverse engineering, decompilation, or disassembly of this software
   is permitted with respect to any software provided in binary form.

 * Any redistribution and use are licensed by TI for use only with TI Devices.

 * Nothing shall obligate TI to provide you with source code for the software
   licensed and provided to you in object code.

 If software source code is provided to you, modification and redistribution of
 the source code are permitted provided that the following conditions are met:

 * Any redistribution and use of the source code, including any resulting
   derivative works, are licensed by TI for use only with TI Devices.

 * Any redistribution and use of any object code compiled from the source code
   and any resulting derivative works, are licensed by TI for use only with TI
   Devices.

 Neither the name of Texas Instruments Incorporated nor the names of its
 suppliers may be used to endorse or promote products derived from this software
 without specific prior written permission.

 DISCLAIMER.

 THIS SOFTWARE IS PROVIDED BY TI AND TI�S LICENSORS "AS IS" AND ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL TI AND TI�S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************/

/*******************************************************************************
 *  INCLUDE FILES
 *******************************************************************************
 */
#include "Chains_camera_ov2775_capture_display_priv.h"
#include <src/include/chains_common.h>
#include <src/rtos/iss/include/iss_sensors.h>
#include <src/rtos/iss/include/iss_utils.h>
#include <src/rtos/iss/include/app_util_iss.h>

#define CAPTURE_SENSOR_WIDTH    (1280)
#define CAPTURE_SENSOR_HEIGHT   (720)

/*
 * AEWB algorithm memory requirement cannot be calculated upfront.
 * This size is known by running the use-case once with large size
 * and then checking the log for unused memory in AEWB algorithm
 */
#define ALG_AEWB_MEM_SIZE                           (896*1024)


/**
 *******************************************************************************
 *
 *  \brief  SingleCameraFrameCopyObject
 *
 *        This structure contains all the LinksId's and create Params.
 *        The same is passed to all create, start, stop functions.
 *
 *******************************************************************************
*/
typedef struct {

    Chains_camera_ov2775_capture_displayObj  ucObj;

//    IssM2mSimcopLink_ConfigParams   simcopConfig;
//    vpsissldcConfig_t               ldcCfg;
//    vpsissvtnfConfig_t              vtnfCfg;

    UInt32                          captureOutWidth;
    UInt32                          captureOutHeight;
    UInt32                          displayWidth;
    UInt32                          displayHeight;

    Chains_Ctrl                    *chainsCfg;

//    IssM2mSimcopLink_OperatingMode  simcopMode;
//    Bool                            bypassVtnf;
//    Bool                            bypassLdc;

    AppUtils_Obj             appSensInfo;
} Chains_camera_ov2775_capture_displayAppObj;


char gChains_camera_ov2775_capture_display_runTimeMenu[] = {
"\r\n "
"\r\n ===================="
"\r\n Chains Run-time Menu"
"\r\n ===================="
"\r\n "
"\r\n 0: Stop Chain"
"\r\n "
"\r\n p: Print Performance Statistics "
"\r\n "
"\r\n Enter Choice: "
"\r\n "
};

/*
 * This function shows an example of allocating memory for
 * a link from within the use-case instead of from within the link
 *
 * This allows user's to potentially allocate memory statically outside of
 * link implementation and then pass the memory to the link during use-case
 * create.
 *
 * If user wants the link to allocate memory then dont set below parameters
 * <link create params>.memAllocInfo.memSize,
 * <link create params>.memAllocInfo.memAddr
 */
Void Chains_camera_ov2775_capture_display_SetMemAllocInfo(
                    Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    UInt32 align = SYSTEM_BUFFER_ALIGNMENT; /* 32 byte alignment*/
    IssCaptureLink_CreateParams             *pIssCapturePrm;
    IssM2mIspLink_CreateParams              *pIssM2mIspPrm;
//    IssRszLink_CreateParams                 *pIssRszPrm;
//    IssM2mSimcopLink_CreateParams           *pIssM2mSimcopPrm;
    AlgorithmLink_IssAewbCreateParams       *pAlg_IssAewbPrm;

    pIssCapturePrm    = &pObj->ucObj.IssCapturePrm;
    pIssM2mIspPrm     = &pObj->ucObj.IssM2mIspPrm;
//    pIssRszPrm        = &pObj->ucObj.IssM2mResizerPrm;
//    pIssM2mSimcopPrm  = &pObj->ucObj.IssM2mSimcopPrm;
    pAlg_IssAewbPrm   = &pObj->ucObj.Alg_IssAewbPrm;


    pIssCapturePrm->memAllocInfo.memSize =
          SystemUtils_align(pObj->captureOutWidth, align)
        * pObj->captureOutHeight
        * 2 /* 16-bit per pixel */
        * (pIssCapturePrm->outParams[0].numOutBuf+1)
            /* +1 for RAW data dump */
        ;

    pAlg_IssAewbPrm->memAllocInfo.memSize = ALG_AEWB_MEM_SIZE;

    pIssM2mIspPrm->memAllocInfo.memSize = 0;

/*    if(pIssM2mIspPrm->channelParams[0].enableOut[ISSM2MISP_LINK_OUTPUTQUE_IMAGE_RSZ_A])
    {
#ifdef ISS_ENABLE_DEBUG_TAPS
        // RSZ A output 
        pIssM2mIspPrm->memAllocInfo.memSize +=
              SystemUtils_align(pIssM2mIspPrm->channelParams[0].outParams.widthRszA, align)
            * pIssM2mIspPrm->channelParams[0].outParams.heightRszA
            * 2 // YUV420/422/RAW 
            * pIssM2mIspPrm->channelParams[0].numBuffersPerCh
            ;
#else
        // RSZ A output 
        pIssM2mIspPrm->memAllocInfo.memSize +=
              SystemUtils_align(pIssM2mIspPrm->channelParams[0].outParams.widthRszA, align)
            * pIssM2mIspPrm->channelParams[0].outParams.heightRszA
            * 1.5 // YUV420SP 
            * pIssM2mIspPrm->channelParams[0].numBuffersPerCh
            ;
#endif
    }
*/
    if( pIssM2mIspPrm->channelParams[0].operatingMode
          == ISSM2MISP_LINK_OPMODE_2PASS_WDR
       )
    {
        // Intermediate buffer in 2 pass WDR mode 
        pIssM2mIspPrm->memAllocInfo.memSize +=
              SystemUtils_align(pObj->captureOutWidth, align)
            * pObj->captureOutHeight
            * 2 /* 16-bit per pixel */
            ;
    }

    if( pIssM2mIspPrm->channelParams[0].operatingMode
          == ISSM2MISP_LINK_OPMODE_2PASS_WDR_LINE_INTERLEAVED
       )
    {
        /* Intermediate buffer in 2 pass WDR mode */
        pIssM2mIspPrm->memAllocInfo.memSize +=
              SystemUtils_align(pIssM2mIspPrm->channelParams[0].wdrOffsetPrms.width, align)
            * pIssM2mIspPrm->channelParams[0].wdrOffsetPrms.height
            * 2 /* 16-bit per pixel */
            ;
    }

    if (pIssM2mIspPrm->allocBufferForDump)
    {
        /* For Dumping Output frame */
        pIssM2mIspPrm->memAllocInfo.memSize +=
              SystemUtils_align(pObj->captureOutWidth, align)
            * pObj->captureOutHeight
            * 2 /* 16-bit per pixel */
            ;
    }

/*    if(pIssM2mIspPrm->channelParams[0].enableOut[ISSM2MISP_LINK_OUTPUTQUE_IMAGE_RSZ_B])
    {
        // RSZ B output 
        pIssM2mIspPrm->memAllocInfo.memSize +=
              SystemUtils_align(pIssM2mIspPrm->channelParams[0].outParams.widthRszB, align)
            * pIssM2mIspPrm->channelParams[0].outParams.heightRszB
            * 1.5 // YUV420SP 
            * pIssM2mIspPrm->channelParams[0].numBuffersPerCh
            ;
    }
*/
    if(pIssM2mIspPrm->channelParams[0].enableOut[ISSM2MISP_LINK_OUTPUTQUE_H3A])
    {
        /* H3A output */
        pIssM2mIspPrm->memAllocInfo.memSize +=
              ((pIssM2mIspPrm->channelParams[0].outParams.widthRszA/
                  pIssM2mIspPrm->channelParams[0].outParams.winWidthH3a)+1)
            * ((pIssM2mIspPrm->channelParams[0].outParams.heightRszA/
                  pIssM2mIspPrm->channelParams[0].outParams.winHeightH3a)+1)
            * ( sizeof(IssAwebH3aOutSumModeOverlay)
              + sizeof(IssAwebH3aOutUnsatBlkCntOverlay) )
            * pIssM2mIspPrm->channelParams[0].numBuffersPerCh
            ;
    }

/* To support WDR, two sets of statistics must be produced, one for short exposure and the other one for long exposure
    that's why there is a factor 2
    */
    if(pIssM2mIspPrm->channelParams[0].enableOut[ISSM2MISP_LINK_OUTPUTQUE_H3A_AF])
    {
        pIssM2mIspPrm->memAllocInfo.memSize +=  SystemUtils_align(2*pIssM2mIspPrm->channelParams[0].outParams.paxelNumHaf
            *pIssM2mIspPrm->channelParams[0].outParams.paxelNumVaf*sizeof(IssAfH3aOutOverlay), 128U) /* DSP cache requires 128 bytes alignment */
            *pIssM2mIspPrm->channelParams[0].numBuffersPerCh;
    }

/*    pIssRszPrm->memAllocInfo.memSize =
          SystemUtils_align(pIssRszPrm->channelParams[0].outParams.widthRszA, align)
        * pIssRszPrm->channelParams[0].outParams.heightRszA
        * 1.5 // YUV420SP 
        * pIssRszPrm->channelParams[0].numBuffersPerCh
        ;

    pIssM2mSimcopPrm->memAllocInfo.memSize =
          SystemUtils_align(pIssM2mIspPrm->channelParams[0].outParams.widthRszA, align)
        * pIssM2mIspPrm->channelParams[0].outParams.heightRszA
        * 1.5
        * (pIssM2mSimcopPrm->channelParams[0].numBuffersPerCh+1)
           // +1 for YUV data dump 
        ;
*/
    pIssCapturePrm->memAllocInfo.memAddr =
        (UInt32)Utils_memAlloc(
                UTILS_HEAPID_DDR_CACHED_SR,
                pIssCapturePrm->memAllocInfo.memSize,
                align
            );
    UTILS_assert(pIssCapturePrm->memAllocInfo.memAddr!=NULL);

    pAlg_IssAewbPrm->memAllocInfo.memAddr =
        (UInt32)Utils_memAlloc(
                UTILS_HEAPID_DDR_CACHED_SR,
                pAlg_IssAewbPrm->memAllocInfo.memSize,
                align
            );
    UTILS_assert(pAlg_IssAewbPrm->memAllocInfo.memAddr!=NULL);

    pIssM2mIspPrm->memAllocInfo.memAddr =
        (UInt32)Utils_memAlloc(
                UTILS_HEAPID_DDR_CACHED_SR,
                pIssM2mIspPrm->memAllocInfo.memSize,
                align
            );
    UTILS_assert(pIssM2mIspPrm->memAllocInfo.memAddr!=NULL);

/*    pIssRszPrm->memAllocInfo.memAddr =
        (UInt32)Utils_memAlloc(
                UTILS_HEAPID_DDR_CACHED_SR,
                pIssRszPrm->memAllocInfo.memSize,
                align
            );
    UTILS_assert(pIssRszPrm->memAllocInfo.memAddr!=NULL);

    pIssM2mSimcopPrm->memAllocInfo.memAddr =
        (UInt32)Utils_memAlloc(
                UTILS_HEAPID_DDR_CACHED_SR,
                pIssM2mSimcopPrm->memAllocInfo.memSize,
                align
            );
    UTILS_assert(pIssM2mSimcopPrm->memAllocInfo.memAddr!=NULL);*/
}

/*
 * This function free's memory allocated by the use-case, if any
 */
Void Chains_camera_ov2775_capture_display_FreeMemory(
                    Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    Int32 status;
    IssCaptureLink_CreateParams             *pIssCapturePrm;
    IssM2mIspLink_CreateParams              *pIssM2mIspPrm;
//    IssRszLink_CreateParams                 *pIssRszPrm;
//    IssM2mSimcopLink_CreateParams           *pIssM2mSimcopPrm;
    AlgorithmLink_IssAewbCreateParams       *pAlg_IssAewbPrm;

    pIssCapturePrm    = &pObj->ucObj.IssCapturePrm;
    pIssM2mIspPrm     = &pObj->ucObj.IssM2mIspPrm;
//    pIssRszPrm        = &pObj->ucObj.IssM2mResizerPrm;
//    pIssM2mSimcopPrm  = &pObj->ucObj.IssM2mSimcopPrm;
    pAlg_IssAewbPrm   = &pObj->ucObj.Alg_IssAewbPrm;

    if(pIssCapturePrm->memAllocInfo.memAddr)
    {
        status = Utils_memFree(
                    UTILS_HEAPID_DDR_CACHED_SR,
                    (Ptr)pIssCapturePrm->memAllocInfo.memAddr,
                    pIssCapturePrm->memAllocInfo.memSize
            );
        UTILS_assert(status==0);
    }

    if(pAlg_IssAewbPrm->memAllocInfo.memAddr)
    {
        status = Utils_memFree(
                    UTILS_HEAPID_DDR_CACHED_SR,
                    (Ptr)pAlg_IssAewbPrm->memAllocInfo.memAddr,
                    pAlg_IssAewbPrm->memAllocInfo.memSize
            );
        UTILS_assert(status==0);
    }

    if(pIssM2mIspPrm->memAllocInfo.memAddr)
    {
        status = Utils_memFree(
                    UTILS_HEAPID_DDR_CACHED_SR,
                    (Ptr)pIssM2mIspPrm->memAllocInfo.memAddr,
                    pIssM2mIspPrm->memAllocInfo.memSize
            );
        UTILS_assert(status==0);
    }

 /*   if(pIssRszPrm->memAllocInfo.memAddr)
    {
        status = Utils_memFree(
                    UTILS_HEAPID_DDR_CACHED_SR,
                    (Ptr)pIssRszPrm->memAllocInfo.memAddr,
                    pIssRszPrm->memAllocInfo.memSize
            );
        UTILS_assert(status==0);
    }

    if(pIssM2mSimcopPrm->memAllocInfo.memAddr)
    {
        status = Utils_memFree(
                    UTILS_HEAPID_DDR_CACHED_SR,
                    (Ptr)pIssM2mSimcopPrm->memAllocInfo.memAddr,
                    pIssM2mSimcopPrm->memAllocInfo.memSize
            );
        UTILS_assert(status==0);
    } */
}

/**
 *******************************************************************************
 *
 * \brief   Set Display Create Parameters
 *
 *          This function is used to set the Display params.
 *          It is called in Create function. It is advisable to have
 *          chains_issIspSimcop_Display_ResetLinkPrms prior to set params
 *          so all the default params get set.
 *
 * \param   pPrm         [IN]    DisplayLink_CreateParams
 *
 *******************************************************************************
*/
Void Chains_camera_ov2775_capture_display_SetDisplayPrms(
                                    DisplayLink_CreateParams *pPrm_Video,
//                                    DisplayLink_CreateParams *pPrm_Grpx,
//                                    DisplayLink_CreateParams *pPrm_VideoRszB,
                                    Chains_DisplayType displayType,
                                    UInt32 displayWidth,
                                    UInt32 displayHeight,
                                    UInt32 captureWidth,
                                    UInt32 captureHeight)
{
    UInt32 dispWidth, dispHeight;

    if(pPrm_Video)
    {
        if((displayType == CHAINS_DISPLAY_TYPE_SDTV_NTSC) ||
          (displayType == CHAINS_DISPLAY_TYPE_SDTV_PAL))
        {
            pPrm_Video->displayScanFormat = SYSTEM_SF_INTERLACED;
        }

        /* To maintain the aspect ratio, change the display tarWidth */
        dispWidth = captureWidth * displayHeight / captureHeight;
        dispHeight = displayHeight;

        if (dispWidth > displayWidth)
        {
            dispWidth = displayWidth;
            dispHeight = displayWidth * captureHeight / captureWidth;
        }


        pPrm_Video->rtParams.tarWidth  = dispWidth;
        pPrm_Video->rtParams.tarHeight = dispHeight;
        pPrm_Video->rtParams.posX      = (displayWidth - dispWidth) / 2U;
        pPrm_Video->rtParams.posY      = (displayHeight - dispHeight) / 2U;

        pPrm_Video->displayId          = DISPLAY_LINK_INST_DSS_VID1;
    }

 /*   if(pPrm_VideoRszB)
    {
        if((displayType == CHAINS_DISPLAY_TYPE_SDTV_NTSC) ||
          (displayType == CHAINS_DISPLAY_TYPE_SDTV_PAL))
        {
            pPrm_VideoRszB->displayScanFormat = SYSTEM_SF_INTERLACED;
        }

        pPrm_VideoRszB->rtParams.tarWidth  = displayWidth/3;
        pPrm_VideoRszB->rtParams.tarHeight = displayHeight/3;
        pPrm_VideoRszB->rtParams.posX = displayWidth -
            pPrm_VideoRszB->rtParams.tarWidth - 10;
        pPrm_VideoRszB->rtParams.posY = displayHeight -
            pPrm_VideoRszB->rtParams.tarHeight - 10;
        pPrm_VideoRszB->displayId = DISPLAY_LINK_INST_DSS_VID2;
    }

    if(pPrm_Grpx)
    {
        if((displayType == CHAINS_DISPLAY_TYPE_SDTV_NTSC) ||
          (displayType == CHAINS_DISPLAY_TYPE_SDTV_PAL))
        {
            pPrm_Grpx->displayScanFormat = SYSTEM_SF_INTERLACED;
        }

        pPrm_Grpx->displayId = DISPLAY_LINK_INST_DSS_GFX1;
    } */
}

/*Void Chains_camera_ov2775_capture_display_SetSimcopConfig(
            Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    IssM2mSimcopLink_ConfigParams_Init(&pObj->simcopConfig);

    pObj->simcopConfig.ldcConfig = &pObj->ldcCfg;
    pObj->simcopConfig.vtnfConfig = &pObj->vtnfCfg;

    IssUtils_InitSimcopConfig(
        &pObj->simcopConfig, pObj->bypassLdc, pObj->bypassVtnf);

    IssUtils_SetimcopLdcVtnfRtConfig(
        &pObj->ldcCfg,
        &pObj->vtnfCfg,
        pObj->bypassLdc,
        pObj->bypassVtnf);

    // MUST be called after link create and before link start 
    System_linkControl(
            pObj->ucObj.IssM2mSimcopLinkID,
            ISSM2MSIMCOP_LINK_CMD_SET_SIMCOPCONFIG,
            &pObj->simcopConfig,
            sizeof(pObj->simcopConfig),
            TRUE);
}
*/

Void Chains_camera_ov2775_capture_display_SetIspConfig(
            Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    appSetDefaultIspParams(&pObj->appSensInfo);
    appSetIspParamsFromDCC(&pObj->appSensInfo);
}

Void Chains_camera_ov2775_capture_display_setMuxes(
            Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    /* Setup PinMux */
    ChainsPlatform_SetPinMux(pObj->chainsCfg->sensorName);

    /* Init Board Mux */
    ChainsBoard_SetBoardMux(pObj->chainsCfg->sensorName);
}

/*Void chains_issIspSimcop_Display_SetIssRszPrms(
        IssRszLink_CreateParams *issRszPrms,
        UInt32 outWidth,
        UInt32 outHeight)
{
    IssRszLink_ChannelParams *chPrms;

    chPrms = issRszPrms->channelParams;

    chPrms->enableOut[0U] = TRUE;
    chPrms->outParams.heightRszA = outHeight;
    chPrms->outParams.widthRszA = outWidth;
    chPrms->outParams.dataFormat = SYSTEM_DF_YUV420SP_UV;
}
*/
/**
 *******************************************************************************
 *
 * \brief   Set link Parameters
 *
 *          It is called in Create function of the auto generated use-case file.
 *
 * \param pUcObj    [IN] Auto-generated usecase object
 * \param appObj    [IN] Application specific object
 *
 *******************************************************************************
*/
Void Chains_camera_ov2775_capture_display_SetAppPrms(
    Chains_camera_ov2775_capture_displayObj *pUcObj, Void *appObj)
{
    Chains_camera_ov2775_capture_displayAppObj *pObj
        = (Chains_camera_ov2775_capture_displayAppObj*) appObj;

    ChainsCommon_GetDisplayWidthHeight(
        pObj->chainsCfg->displayType,
        &pObj->displayWidth,
        &pObj->displayHeight
        );

/*    pObj->simcopMode = ISSM2MSIMCOP_LINK_OPMODE_LDC_VTNF;
    pObj->bypassVtnf = FALSE;
    pObj->bypassLdc  = FALSE;

    if ((pObj->chainsCfg->issLdcEnable == FALSE) &&
        (pObj->chainsCfg->issVtnfEnable == TRUE))
    {
        pObj->simcopMode = ISSM2MSIMCOP_LINK_OPMODE_VTNF;
        pObj->bypassVtnf = FALSE;
        pObj->bypassLdc  = TRUE;
    }
    else if ((pObj->chainsCfg->issLdcEnable == TRUE) &&
             (pObj->chainsCfg->issVtnfEnable == FALSE))
    {
        pObj->simcopMode = ISSM2MSIMCOP_LINK_OPMODE_LDC;
        pObj->bypassVtnf = TRUE;
        pObj->bypassLdc  = FALSE;
    }
    else if ((pObj->chainsCfg->issLdcEnable == FALSE) &&
             (pObj->chainsCfg->issVtnfEnable == FALSE))
    {
        pObj->simcopMode = ISSM2MSIMCOP_LINK_OPMODE_VTNF;
        pObj->bypassVtnf = TRUE;
        pObj->bypassLdc  = TRUE;
    }
*/
    /* Initialize Simcop Pointers */
//    pObj->simcopConfig.ldcConfig = &pObj->ldcCfg;
//    pObj->simcopConfig.vtnfConfig = &pObj->vtnfCfg;

    /* Create the sensor now */
    strncpy(pObj->appSensInfo.sensorName, pObj->chainsCfg->sensorName,
        ISS_SENSORS_MAX_NAME);
    pObj->appSensInfo.numCh = 1;
    pObj->appSensInfo.ispOpMode = pObj->chainsCfg->ispOpMode;
///    pObj->appSensInfo.simcopOpMode = pObj->simcopMode;
    pObj->appSensInfo.numCSI2Inst = 1;
    appCreateISSSensor(&pObj->appSensInfo);

    appInitIssCaptParams(&pObj->appSensInfo, pUcObj->IssCaptureLinkID,
        &pUcObj->IssCapturePrm);
    appInitIssIspParams(&pObj->appSensInfo, pUcObj->IssM2mIspLinkID,
        &pUcObj->IssM2mIspPrm);
//    appInitIssSimcopParams(&pObj->appSensInfo, pUcObj->IssM2mSimcopLinkID,
//        &pUcObj->IssM2mSimcopPrm);
    appInitIssAewbParams(&pObj->appSensInfo, pUcObj->Alg_IssAewbLinkID,
        &pUcObj->Alg_IssAewbPrm);

    /* Resizer B output will be shown as 1/3rd of display size */
//    pUcObj->IssM2mIspPrm.channelParams[0u].outParams.widthRszB  =
//        (pObj->displayWidth / 3) & (~0x1U);
//    pUcObj->IssM2mIspPrm.channelParams[0u].outParams.heightRszB =
//        (pObj->displayHeight / 3) & (~0x1U);

    /* Display requires around 4 buffers for 60fps chain, so increasing
       simcop output buffers to 4 */
//    pUcObj->IssM2mSimcopPrm.channelParams[0u].numBuffersPerCh = 4;
//    pUcObj->IssM2mResizerPrm.channelParams[0u].numBuffersPerCh = 4U;

    pUcObj->IssM2mIspPrm.allocBufferForDump = TRUE;
    pUcObj->IssCapturePrm.allocBufferForRawDump = TRUE;

/*    ChainsCommon_SetGrpxSrcPrms(&pUcObj->GrpxSrcPrm,
                                pObj->displayWidth,
                                pObj->displayHeight);
*/
/*    chains_issIspSimcop_Display_SetIssRszPrms(
        &pUcObj->IssM2mResizerPrm,
        ((pObj->displayWidth/3) & ~0x1), // Even value needed 
        (pObj->displayHeight/3));*/
	pObj->captureOutWidth = CAPTURE_SENSOR_WIDTH;
	pObj->captureOutHeight = CAPTURE_SENSOR_HEIGHT; 
/*    pObj->captureOutWidth = pUcObj->IssCapturePrm.outParams[0U].width;
    pObj->captureOutHeight = pUcObj->IssCapturePrm.outParams[0U].height;*/

    /*
     * call this function to allocate memory from use-case
     * if this function is not called memory is allocated
     * from within the respective link
     */
//    Chains_camera_ov2775_capture_display_SetMemAllocInfo(pObj);

    Chains_camera_ov2775_capture_display_SetDisplayPrms(
        &pUcObj->Display_VideoPrm,
            pObj->chainsCfg->displayType,
            pObj->displayWidth,
            pObj->displayHeight,
	    pObj->captureOutWidth,
	    pObj->captureOutHeight); 	
//            pUcObj->IssM2mIspPrm.channelParams[0U].outParams.widthRszA,
//            pUcObj->IssM2mIspPrm.channelParams[0U].outParams.heightRszA);

    ChainsCommon_StartDisplayCtrl(
        pObj->chainsCfg->displayType,
        pObj->displayWidth,
        pObj->displayHeight);
}

/**
 *******************************************************************************
 *
 * \brief   Start the capture display Links
 *
 *          Function sends a control command to capture and display link to
 *          to Start all the required links . Links are started in reverce
 *          order as information of next link is required to connect.
 *          System_linkStart is called with LinkId to start the links.
 *
 * \param   pObj  [IN] chains_issIspSimcop_DisplayAppObj
 *
 * \return  SYSTEM_LINK_STATUS_SOK on success
 *
 *******************************************************************************
*/
Void Chains_camera_ov2775_capture_display_StartApp(Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    Chains_memPrintHeapStatus();

    /* Sets the Simcop Config also */
    Chains_camera_ov2775_capture_display_SetIspConfig(pObj);
//    chains_issIspSimcop_Display_SetSimcopConfig(pObj);

    Chains_camera_ov2775_capture_display_setMuxes(pObj);

    appStartIssSensorSerDes(&pObj->appSensInfo);

    ChainsCommon_StartDisplayDevice(pObj->chainsCfg->displayType);

    Chains_camera_ov2775_capture_display_Start(&pObj->ucObj);

    Chains_prfLoadCalcEnable(TRUE, FALSE, FALSE);
}

/**
 *******************************************************************************
 *
 * \brief   Delete the capture display Links
 *
 *          Function sends a control command to capture and display link to
 *          to delete all the prior created links
 *          System_linkDelete is called with LinkId to delete the links.
 *
 * \param   pObj   [IN]   chains_issIspSimcop_DisplayAppObj
 *
 *******************************************************************************
*/
Void Chains_camera_ov2775_capture_display_StopAndDeleteApp(Chains_camera_ov2775_capture_displayAppObj *pObj)
{
    Chains_camera_ov2775_capture_display_Stop(&pObj->ucObj);
    Chains_camera_ov2775_capture_display_Delete(&pObj->ucObj);

    Chains_camera_ov2775_capture_display_FreeMemory(pObj);

    ChainsCommon_StopDisplayCtrl();

    appStopISSSensor(&pObj->appSensInfo);

    appDeleteISSSensor(&pObj->appSensInfo);

    ChainsCommon_StopDisplayDevice(pObj->chainsCfg->displayType);

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

/**
 *******************************************************************************
 *
 * \brief   Single Channel Capture Display usecase function
 *
 *          This functions executes the create, start functions
 *
 *          Further in a while loop displays run time menu and waits
 *          for user inputs to print the statistics or to end the demo.
 *
 *          Once the user inputs end of demo stop and delete
 *          functions are executed.
 *
 * \param   chainsCfg       [IN]   Chains_Ctrl
 *
 *******************************************************************************
*/
Void Chains_camera_ov2775_capture_display(Chains_Ctrl *chainsCfg)
{
    char ch;
    UInt32 done = FALSE;
    Chains_camera_ov2775_capture_displayAppObj chainsObj;
//    IssM2mIspLink_IspOutputTapParams ispTapPrms;
//    Int32 CapImCounter = 0;
//    char fName[128];
//    Int32 status = 0;
//    IssCaptureLink_GetSaveFrameStatus rawSaveFrameStatus;
//    IssM2mSimcopLink_GetSaveFrameStatus simcopSaveFrameStatus;
//    IssM2mIspLink_GetSaveFrameStatus ispSaveFrameStatus;
//    UInt32 chId = 0U;

//    chainsObj.bypassVtnf = 0; /* KW error fix */
//    chainsObj.bypassLdc  = 0; /* KW error fix */


    Vps_printf(" Entered Chains_issIspSimcop_Display \n");

    if (TRUE == IssM2mIspLink_IsWdrMode(chainsCfg->ispOpMode))
    {
        Vps_printf(" CHAINS: Please make sure BSP is build with WDR and LDC enabled !!!\n");
    }

    chainsObj.chainsCfg = chainsCfg;

    /* Initialize Video Sensor, so that Algorithm can use Params
       from Vid Sensor layer */
    Chains_camera_ov2775_capture_display_Create(&chainsObj.ucObj, &chainsObj);
    ChainsCommon_SetIssCaptureErrorHandlingCb(chainsObj.ucObj.IssCaptureLinkID);
    Chains_camera_ov2775_capture_display_StartApp(&chainsObj);

    while(!done)
    {
        Vps_printf(gChains_camera_ov2775_capture_display_runTimeMenu);

        ch = Chains_readChar();

        switch(ch)
        {
            case '0':
                done = TRUE;
                break;
            case 'p':
            case 'P':
                ChainsCommon_PrintStatistics();
                Chains_camera_ov2775_capture_display_printStatistics(&chainsObj.ucObj);
                break;
            default:
                Vps_printf("\nUnsupported option '%c'. Please try again\n", ch);
                break;
        }
    }

    Chains_camera_ov2775_capture_display_StopAndDeleteApp(&chainsObj);

}

/****************************************************************************
Copyright (c) [2012 - 2017] Texas Instruments Incorporated

All rights reserved not granted herein.

Limited License.

 Texas Instruments Incorporated grants a world-wide, royalty-free, non-exclusive
 license under copyrights and patents it now or hereafter owns or controls to
 make,  have made, use, import, offer to sell and sell ('Utilize') this software
 subject to the terms herein.  With respect to the foregoing patent license,
 such license is granted  solely to the extent that any such patent is necessary
 to Utilize the software alone.  The patent license shall not apply to any
 combinations which include this software, other than combinations with devices
 manufactured by or for TI ('TI Devices').  No hardware patent is licensed
 hereunder.

 Redistributions must preserve existing copyright notices and reproduce this
 license (including the above copyright notice and the disclaimer and
 (if applicable) source code license limitations below) in the documentation
 and/or other materials provided with the distribution

 Redistribution and use in binary form, without modification, are permitted
 provided that the following conditions are met:

 * No reverse engineering, decompilation, or disassembly of this software
   is permitted with respect to any software provided in binary form.

 * Any redistribution and use are licensed by TI for use only with TI Devices.

 * Nothing shall obligate TI to provide you with source code for the software
   licensed and provided to you in object code.

 If software source code is provided to you, modification and redistribution of
 the source code are permitted provided that the following conditions are met:

 * Any redistribution and use of the source code, including any resulting
   derivative works, are licensed by TI for use only with TI Devices.

 * Any redistribution and use of any object code compiled from the source code
   and any resulting derivative works, are licensed by TI for use only with TI
   Devices.

 Neither the name of Texas Instruments Incorporated nor the names of its
 suppliers may be used to endorse or promote products derived from this software
 without specific prior written permission.

 DISCLAIMER.

 THIS SOFTWARE IS PROVIDED BY TI AND TI�S LICENSORS 'AS IS' AND ANY EXPRESS OR
 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 IN NO EVENT SHALL TI AND TI�S LICENSORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************
*/
/*
*******************************************************************************
*
* IMPORTANT NOTE:
*  This file is AUTO-GENERATED by Vision SDK use case generation tool
*
*******************************************************************************
*/
#include "Chains_camera_ov2775_capture_display_priv.h"
Void Chains_camera_ov2775_capture_display_SetLinkId(Chains_camera_ov2775_capture_displayObj *pObj){
       pObj->IssCaptureLinkID               = SYSTEM_LINK_ID_ISSCAPTURE_0;
       pObj->IssM2mIspLinkID                = SYSTEM_LINK_ID_ISSM2MISP_0;
       pObj->Alg_IssAewbLinkID              = IPU1_0_LINK (SYSTEM_LINK_ID_ALG_0);
       pObj->Display_VideoLinkID            = SYSTEM_LINK_ID_DISPLAY_0;
}

Void Chains_camera_ov2775_capture_display_ResetLinkPrms(Chains_camera_ov2775_capture_displayObj *pObj){
       IssCaptureLink_CreateParams_Init(&pObj->IssCapturePrm);
       IssM2mIspLink_CreateParams_Init(&pObj->IssM2mIspPrm);
       AlgorithmLink_IssAewb_Init(&pObj->Alg_IssAewbPrm);
       DisplayLink_CreateParams_Init(&pObj->Display_VideoPrm);
}

Void Chains_camera_ov2775_capture_display_SetPrms(Chains_camera_ov2775_capture_displayObj *pObj){
       (pObj->Alg_IssAewbPrm).baseClassCreate.size  = sizeof(AlgorithmLink_IssAewbCreateParams);
       (pObj->Alg_IssAewbPrm).baseClassCreate.algId  = ALGORITHM_LINK_IPU_ALG_ISS_AEWB1;
}

Void Chains_camera_ov2775_capture_display_ConnectLinks(Chains_camera_ov2775_capture_displayObj *pObj){

       //IssCapture -> IssM2mIsp
       pObj->IssCapturePrm.outQueParams.nextLink = pObj->IssM2mIspLinkID;
       pObj->IssM2mIspPrm.inQueParams[0].prevLinkId = pObj->IssCaptureLinkID;
       pObj->IssM2mIspPrm.inQueParams[0].prevLinkQueId = 0;

       //IssM2mIsp -> Display_Video
       pObj->IssM2mIspPrm.outQueParams[0].nextLink = pObj->Display_VideoLinkID;
       pObj->Display_VideoPrm.inQueParams.prevLinkId = pObj->IssM2mIspLinkID;
       pObj->Display_VideoPrm.inQueParams.prevLinkQueId = 0;

       //IssM2mIsp -> Alg_IssAewb
       pObj->IssM2mIspPrm.outQueParams[1].nextLink = pObj->Alg_IssAewbLinkID;
       pObj->Alg_IssAewbPrm.inQueParams.prevLinkId = pObj->IssM2mIspLinkID;
       pObj->Alg_IssAewbPrm.inQueParams.prevLinkQueId = 1;

}

Int32 Chains_camera_ov2775_capture_display_Create(Chains_camera_ov2775_capture_displayObj *pObj, Void *appObj){

       Int32 status;

       Chains_camera_ov2775_capture_display_SetLinkId(pObj);
       Chains_camera_ov2775_capture_display_ResetLinkPrms(pObj);

       Chains_camera_ov2775_capture_display_SetPrms(pObj);
       Chains_camera_ov2775_capture_display_SetAppPrms(pObj, appObj);

       Chains_camera_ov2775_capture_display_ConnectLinks(pObj);
       status = System_linkCreate(pObj->IssCaptureLinkID, &pObj->IssCapturePrm, sizeof(pObj->IssCapturePrm));
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkCreate(pObj->IssM2mIspLinkID, &pObj->IssM2mIspPrm, sizeof(pObj->IssM2mIspPrm));
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkCreate(pObj->Alg_IssAewbLinkID, &pObj->Alg_IssAewbPrm, sizeof(pObj->Alg_IssAewbPrm));
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkCreate(pObj->Display_VideoLinkID, &pObj->Display_VideoPrm, sizeof(pObj->Display_VideoPrm));
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       return status;
}

Int32 Chains_camera_ov2775_capture_display_Start(Chains_camera_ov2775_capture_displayObj *pObj){

       Int32 status;

       status = System_linkStart(pObj->Display_VideoLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkStart(pObj->Alg_IssAewbLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkStart(pObj->IssM2mIspLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkStart(pObj->IssCaptureLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       return status;
}

Int32 Chains_camera_ov2775_capture_display_Stop(Chains_camera_ov2775_capture_displayObj *pObj){

       Int32 status;

       status = System_linkStop(pObj->Display_VideoLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkStop(pObj->Alg_IssAewbLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkStop(pObj->IssM2mIspLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkStop(pObj->IssCaptureLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       return status;
}

Int32 Chains_camera_ov2775_capture_display_Delete(Chains_camera_ov2775_capture_displayObj *pObj){

       Int32 status;

       status = System_linkDelete(pObj->Display_VideoLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkDelete(pObj->Alg_IssAewbLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkDelete(pObj->IssM2mIspLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       status = System_linkDelete(pObj->IssCaptureLinkID);
       UTILS_assert(status == SYSTEM_LINK_STATUS_SOK);

       return status;
}

Void Chains_camera_ov2775_capture_display_printBufferStatistics(Chains_camera_ov2775_capture_displayObj *pObj){
       System_linkPrintBufferStatistics(pObj->IssCaptureLinkID);
       System_linkPrintBufferStatistics(pObj->IssM2mIspLinkID);
       System_linkPrintBufferStatistics(pObj->Alg_IssAewbLinkID);
       System_linkPrintBufferStatistics(pObj->Display_VideoLinkID);
       Task_sleep(500);
}

Void Chains_camera_ov2775_capture_display_printStatistics(Chains_camera_ov2775_capture_displayObj *pObj){
       System_linkPrintStatistics(pObj->IssCaptureLinkID);
       System_linkPrintStatistics(pObj->IssM2mIspLinkID);
       System_linkPrintStatistics(pObj->Alg_IssAewbLinkID);
       System_linkPrintStatistics(pObj->Display_VideoLinkID);
       Task_sleep(500);
}