#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "fh_common.h"
#include "fh_system_mpi.h"
#include "fh_vb_mpi.h"
#include "fh_defines.h"
#include "vmm_api.h"
#include "fh_vo_mpi.h"
#include "types/bufCtrl.h"

#include "common.h"

/*==========================================================================================================*/

#ifdef SAMPLE_VO_DEBUG
#define SAMPLE_VO_PRT(msg, ...)   \
    do {\
          printf("[Func]:%s [Line]:%d: " msg "\n",  __FUNCTION__, __LINE__, ##__VA_ARGS__); \
       }while(0)
#else
#define SAMPLE_VO_PRT(msg, ...) do{}while(0)
#endif

#define SAMPLE_VO_CHECK(cond, msg, ...)  \
      if(cond) { \
          printf("[Func]:%s [Line]:%d: " msg "\n",  __FUNCTION__, __LINE__, ##__VA_ARGS__); \
      } \

#define SAMPLE_VO_CHECK_GOTO(cond, label, msg, ...)  \
      if(cond) { \
          printf("[Func]:%s [Line]:%d: " msg "\n",  __FUNCTION__, __LINE__, ##__VA_ARGS__); \
          goto label; \
      } \

#define SAMPLE_PRT(fmt...)   \
    do {\
        printf("[%s]-%d: ", __FUNCTION__, __LINE__);\
        printf(fmt);\
       }while(0)

#define ALIGN_BACK(x, a)              ((a) * (((x) / (a))))

#define SAMPLE_VO_DEV_DHD0          0
#define SAMPLE_VO_LAYER_VHD0        0
#define SAMPLE_VO_LAYER_VPIP        3
#define SAMPLE_VO_DEV_DSD0          1
#define SAMPLE_VO_LAYER_VSD0        1

#define SAMPLE_PIXEL_FORMAT         PIXEL_FMT_YUV_SEMIPLANAR_422

static FH_BOOL gs_bEnableLcd = FH_FALSE;
static FH_BOOL gs_bEnableVhd0Single = FH_FALSE;
static FH_BOOL gs_bEnableCompress = FH_FALSE;
static FH_UINT32  g_bEnablePIP = FH_FALSE;

/*==========================================================================================================*/

FH_SINT32 SAMPLE_COMM_VO_GetWH(VO_INTF_SYNC_E enIntfSync, FH_UINT32 *pu32W,FH_UINT32 *pu32H, FH_UINT32 *pu32Frm)
{
    switch (enIntfSync)
    {
        case VO_OUTPUT_960H_NTSC :   *pu32W = 480;  *pu32H = 960;  *pu32Frm = 60; break;
        case VO_OUTPUT_PAL       :   *pu32W = 720;  *pu32H = 576;  *pu32Frm = 25; break;
        case VO_OUTPUT_NTSC      :   *pu32W = 720;  *pu32H = 480;  *pu32Frm = 30; break;
        case VO_OUTPUT_576P50    :   *pu32W = 720;  *pu32H = 576;  *pu32Frm = 50; break;
        case VO_OUTPUT_480P60    :   *pu32W = 720;  *pu32H = 480;  *pu32Frm = 60; break;
        case VO_OUTPUT_800x480_60:   *pu32W = 800;  *pu32H = 480;  *pu32Frm = 60; break;
        case VO_OUTPUT_800x600_60:   *pu32W = 800;  *pu32H = 600;  *pu32Frm = 60; break;
        case VO_OUTPUT_800x1280_60:  *pu32W = 800;  *pu32H = 1280; *pu32Frm = 60; break;
        case VO_OUTPUT_720P50    :   *pu32W = 1280; *pu32H = 720;  *pu32Frm = 50; break;
        case VO_OUTPUT_720P60    :   *pu32W = 1280; *pu32H = 720;  *pu32Frm = 60; break;
        case VO_OUTPUT_1080I50   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 25; break;
        case VO_OUTPUT_1080I60   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 30; break;
        case VO_OUTPUT_1080P24   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 24; break;
        case VO_OUTPUT_1080P25   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 25; break;
        case VO_OUTPUT_1080P30   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 30; break;
        case VO_OUTPUT_1080P50   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 50; break;
        case VO_OUTPUT_1080P60   :   *pu32W = 1920; *pu32H = 1080; *pu32Frm = 60; break;
        case VO_OUTPUT_1024x600_60:  *pu32W = 1024; *pu32H = 600;  *pu32Frm = 60; break;
        case VO_OUTPUT_1024x768_60:  *pu32W = 1024; *pu32H = 768;  *pu32Frm = 60; break;
        case VO_OUTPUT_1280x1024_60: *pu32W = 1280; *pu32H = 1024; *pu32Frm = 60; break;
        case VO_OUTPUT_1366x768_60:  *pu32W = 1366; *pu32H = 768;  *pu32Frm = 60; break;
        case VO_OUTPUT_1440x900_60:  *pu32W = 1440; *pu32H = 900;  *pu32Frm = 60; break;
        case VO_OUTPUT_1280x800_60:  *pu32W = 1280; *pu32H = 800;  *pu32Frm = 60; break;
        case VO_OUTPUT_1600x1200_60: *pu32W = 1600; *pu32H = 1200; *pu32Frm = 60; break;
        case VO_OUTPUT_1680x1050_60: *pu32W = 1680; *pu32H = 1050; *pu32Frm = 60; break;
        case VO_OUTPUT_1920x1200_60: *pu32W = 1920; *pu32H = 1200; *pu32Frm = 60; break;
        case VO_OUTPUT_2560x1440_30: *pu32W = 2560; *pu32H = 1440; *pu32Frm = 30; break;
        case VO_OUTPUT_2560x1440_60: *pu32W = 2560; *pu32H = 1440; *pu32Frm = 60; break;
        case VO_OUTPUT_3840x2160_30: *pu32W = 3840; *pu32H = 2160; *pu32Frm = 30; break;
        case VO_OUTPUT_3840x2160_60: *pu32W = 3840; *pu32H = 2160; *pu32Frm = 60; break;
        case VO_OUTPUT_4096x2160_30: *pu32W = 4096; *pu32H = 2160; *pu32Frm = 30; break;
        case VO_OUTPUT_640x480_60:   *pu32W = 640;  *pu32H = 480;  *pu32Frm = 60; break;
        case VO_OUTPUT_240x320_60:   *pu32W = 240;  *pu32H = 320;  *pu32Frm = 60; break;
        case VO_OUTPUT_USER    :     *pu32W = 240;  *pu32H = 320;  *pu32Frm = 30; break;
        default:
            SAMPLE_PRT("vo enIntfSync not support!\n");
            return FH_FAILURE;
    }
    return FH_SUCCESS;
}
FH_SINT32 SAMPLE_COMM_VO_GetChnRect(VO_CHN voChn, SAMPLE_VO_MODE_E enMode, FH_SIZE *pstSize, RECT_S* pstRect)
{
    FH_SINT32 s32Ret = FH_SUCCESS;
    FH_UINT32 u32WndNum = 0;
    FH_UINT32 u32Square = 0;
    FH_UINT32 u32CellH = 0;
    FH_UINT32 u32CellW = 0;
    FH_SINT32 s32XO = 0, s32YO = 0;

    if (NULL == pstSize || NULL == pstRect) {
        s32Ret = FH_ERR_VO_NULL_PTR;
        goto EXIT;
    }

    switch (enMode) {
        case VO_MODE_1MUX:
            u32WndNum = 1;
            u32Square = 1;
            break;
        case VO_MODE_4MUX:
            u32WndNum = 4;
            u32Square = 2;
            break;
        case VO_MODE_9MUX:
            u32WndNum = 9;
            u32Square = 3;
            break;
        case VO_MODE_16MUX:
            u32WndNum = 16;
            u32Square = 4;
            break;
        case VO_MODE_1B_5S:
            u32WndNum = 6;
            u32Square = 3;
            break;
        case VO_MODE_1B_7S:
            u32WndNum = 8;
            u32Square = 4;
            break;
        case VO_MODE_1L_1R:
            u32WndNum = 2;
            u32Square = 2;
            break;
        case VO_MODE_25MUX:
            u32WndNum = 25;
            u32Square = 5;
            break;
        case VO_MODE_36MUX:
            u32WndNum = 36;
            u32Square = 6;
            break;
        case VO_MODE_49MUX:
            u32WndNum = 49;
            u32Square = 7;
            break;
        case VO_MODE_64MUX:
            u32WndNum = 64;
            u32Square = 8;
            break;
        default:
            break;
    }

    if (VO_MODE_1L_1R == enMode) {
        u32CellW = ALIGN_BACK(pstSize->u32Width/u32Square,  16);
        u32CellH = ALIGN_BACK(pstSize->u32Height, 2);
        s32XO = ALIGN_BACK((pstSize->u32Width - u32CellW*u32Square)/2, 2);
        s32YO = ALIGN_BACK((pstSize->u32Height - u32CellH)/2, 2);
    } else {
        u32CellW = ALIGN_BACK(pstSize->u32Width/u32Square,  16);
        u32CellH = ALIGN_BACK(pstSize->u32Height/u32Square, 2);
        s32XO = ALIGN_BACK((pstSize->u32Width - u32CellW*u32Square)/2, 2);
        s32YO = ALIGN_BACK((pstSize->u32Height - u32CellH*u32Square)/2, 2);
    }


    if (voChn < u32WndNum) {
        if (VO_MODE_1L_1R == enMode) {
            if (0 == voChn) {
                pstRect->s32X = s32XO;
                pstRect->s32Y = s32YO;
                pstRect->u32Width = u32CellW;
                pstRect->u32Height = u32CellH;
            } else if (1 == voChn){
                pstRect->s32X = s32XO + u32CellW;
                pstRect->s32Y = s32YO;
                pstRect->u32Width = u32CellW;
                pstRect->u32Height = u32CellH;
            }
        } else {
            if (VO_MODE_1B_5S == enMode || VO_MODE_1B_7S == enMode) {
                if (0 == voChn) {
                    pstRect->s32X = s32XO;
                    pstRect->s32Y = s32YO;
                } else if (voChn >= u32WndNum - u32Square) {
                    pstRect->s32X = u32CellW * (voChn + u32Square - u32WndNum) + s32XO;
                    pstRect->s32Y = u32CellH * (u32Square - 1) + s32YO;
                } else {
                    pstRect->s32X = u32CellW * (u32Square - 1) + s32XO;
                    pstRect->s32Y = u32CellH * (voChn - 1) + s32YO;
                }
            } else {
                pstRect->s32X = u32CellW * (voChn % u32Square) + s32XO;
                pstRect->s32Y = u32CellH * (voChn / u32Square) + s32YO;
            }

            if ((0 == voChn) && (VO_MODE_1B_5S == enMode || VO_MODE_1B_7S == enMode)) {
                pstRect->u32Width = u32CellW * (u32Square -1);
                pstRect->u32Height = u32CellH * (u32Square -1);
            } else {
                pstRect->u32Width = u32CellW;
                pstRect->u32Height = u32CellH;
            }
        }
    }


EXIT:

    return s32Ret;
}

FH_SINT32 SAMPLE_COMM_VO_StartDev(VO_DEV VoDev, VO_PUB_ATTR_S *pstPubAttr)
{
    FH_SINT32 s32Ret = FH_SUCCESS;

    s32Ret = FH_VO_SetPubAttr(VoDev, pstPubAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_Enable(VoDev);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    return s32Ret;
}

FH_SINT32 SAMPLE_COMM_VO_StopDev(VO_DEV VoDev)
{
    FH_SINT32 s32Ret = FH_SUCCESS;

    s32Ret = FH_VO_Disable(VoDev);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("VoDev:%d,failed with %#x!\n", VoDev,s32Ret);
        return FH_FAILURE;
    }
    return s32Ret;
}

FH_SINT32 SAMPLE_COMM_VO_StartLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr)
{
    FH_SINT32 s32Ret = FH_SUCCESS;
    s32Ret = FH_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_EnableVideoLayer(VoLayer);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    return s32Ret;
}

FH_SINT32 SAMPLE_COMM_VO_StopLayer(VO_LAYER VoLayer)
{
    FH_SINT32 s32Ret = FH_SUCCESS;

    s32Ret = FH_VO_DisableVideoLayer(VoLayer);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }
    return s32Ret;
}

FH_SINT32 SAMPLE_COMM_VO_StartCompressedLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr)
{
    FH_SINT32 s32Ret = FH_SUCCESS;
    VO_COMPRESS_ATTR_S stCompressAttr = {.bSupportCompress = FH_TRUE,};

    s32Ret = FH_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_SetVideoLayerCompressAttr(VoLayer, &stCompressAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_EnableVideoLayer(VoLayer);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    return s32Ret;
}
FH_SINT32 SAMPLE_COMM_VO_StartSingleLayer(VO_LAYER VoLayer,const VO_VIDEO_LAYER_ATTR_S *pstLayerAttr, FH_BOOL isSingle)
{
    FH_SINT32 s32Ret = FH_SUCCESS;
    VO_PART_MODE_E enPartMode = VO_PART_MODE_SINGLE;
    VO_COMPRESS_ATTR_S stCompressAttr = {.bSupportCompress = FH_TRUE,};

    s32Ret = FH_VO_SetVideoLayerAttr(VoLayer, pstLayerAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_SetVideoLayerPartitionMode(VoLayer, enPartMode);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_SetVideoLayerCompressAttr(VoLayer, &stCompressAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    s32Ret = FH_VO_EnableVideoLayer(VoLayer);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    return s32Ret;
}

FH_SINT32 SAMPLE_COMM_VO_StartChn(VO_LAYER VoLayer, SAMPLE_VO_MODE_E enMode)
{
    FH_SINT32 i;
    FH_SINT32 s32Ret = FH_SUCCESS;
    FH_UINT32 u32WndNum = 0;
    VO_CHN_ATTR_S stChnAttr;
    VO_VIDEO_LAYER_ATTR_S stLayerAttr;
    FH_SINT32 s32ChnFrmRate;

    switch (enMode)
    {
        case VO_MODE_1MUX:
            u32WndNum = 1;
            break;
        case VO_MODE_4MUX:
            u32WndNum = 4;
            break;
        case VO_MODE_9MUX:
            u32WndNum = 9;
            break;
        case VO_MODE_16MUX:
            u32WndNum = 16;
            break;
        case VO_MODE_25MUX:
            u32WndNum = 25;
            break;
        case VO_MODE_36MUX:
            u32WndNum = 36;
            break;
        case VO_MODE_49MUX:
            u32WndNum = 49;
            break;
        case VO_MODE_64MUX:
            u32WndNum = 64;
            break;
        case VO_MODE_1B_5S:
            u32WndNum = 6;
            break;
        case VO_MODE_1B_7S:
            u32WndNum = 8;
            break;
        case VO_MODE_1L_1R:
            u32WndNum = 2;
            break;

            break;
        default:
            SAMPLE_PRT("failed with %#x!\n", s32Ret);
            return FH_FAILURE;
    }

    s32Ret = FH_VO_GetVideoLayerAttr(VoLayer, &stLayerAttr);
    if (s32Ret != FH_SUCCESS)
    {
        SAMPLE_PRT("failed with %#x!\n", s32Ret);
        return FH_FAILURE;
    }

    if (stLayerAttr.u32DispFrmRt <= 0)
    {
        s32ChnFrmRate = 30;
    }
    else if (stLayerAttr.u32DispFrmRt > 30)
    {
        s32ChnFrmRate = stLayerAttr.u32DispFrmRt / 2;
    }
    else
    {
        s32ChnFrmRate = stLayerAttr.u32DispFrmRt;
    }

    FH_VO_SetAttrBegin(VoLayer);

    for (i=0; i<u32WndNum; i++)
    {
        s32Ret = SAMPLE_COMM_VO_GetChnRect(i, enMode, &stLayerAttr.stImageSize, &stChnAttr.stRect);
        if (s32Ret != FH_SUCCESS)
        {
            SAMPLE_PRT("failed with %#x!\n", s32Ret);
            return FH_FAILURE;
        }

        stChnAttr.u32Priority       = 0;
        stChnAttr.bDeflicker        = FH_FALSE;

        s32Ret = FH_VO_SetChnAttr(VoLayer, i, &stChnAttr);
        if (s32Ret != FH_SUCCESS)
        {
            printf("%s(%d):failed with %#x!\n", __FUNCTION__, __LINE__, s32Ret);
            return FH_FAILURE;
        }

        s32Ret = FH_VO_SetChnFrameRate(VoLayer, i, s32ChnFrmRate);
        if (FH_SUCCESS != s32Ret)
        {
            SAMPLE_PRT("failed with %#x!\n", s32Ret);
            return FH_FAILURE;
        }

        s32Ret = FH_VO_EnableChn(VoLayer, i);
        if (s32Ret != FH_SUCCESS)
        {
            SAMPLE_PRT("failed with %#x!\n", s32Ret);
            return FH_FAILURE;
        }
    }

    FH_VO_SetAttrEnd(VoLayer);

    return FH_SUCCESS;
}
FH_SINT32 SAMPLE_COMM_VO_StopChn(VO_LAYER VoLayer, SAMPLE_VO_MODE_E enMode)
{
    FH_SINT32 i;
    FH_SINT32 s32Ret = FH_SUCCESS;
    FH_UINT32 u32WndNum = 0;

    switch (enMode)
    {
        case VO_MODE_1MUX:
            u32WndNum = 1;
            break;
        case VO_MODE_4MUX:
            u32WndNum = 4;
            break;
        case VO_MODE_9MUX:
            u32WndNum = 9;
            break;
        case VO_MODE_16MUX:
            u32WndNum = 16;
            break;
        case VO_MODE_1B_5S:
            u32WndNum = 6;
            break;
        case VO_MODE_1B_7S:
            u32WndNum = 8;
            break;
        case VO_MODE_1L_1R:
            u32WndNum = 2;
            break;
        case VO_MODE_25MUX:
            u32WndNum = 25;
            break;
        case VO_MODE_36MUX:
            u32WndNum = 36;
            break;
        case VO_MODE_49MUX:
            u32WndNum = 49;
            break;
        case VO_MODE_64MUX:
            u32WndNum = 64;
            break;
        default:
            SAMPLE_PRT("failed with %#x!\n", s32Ret);
            return FH_FAILURE;
    }

    for (i=0; i<u32WndNum; i++)
    {
        s32Ret = FH_VO_DisableChn(VoLayer, i);
        if (s32Ret != FH_SUCCESS)
        {
            SAMPLE_PRT("failed with %#x!\n", s32Ret);
            return FH_FAILURE;
        }
    }
    return s32Ret;
}


FH_SINT32 vo_test_init(int bIsHD, int _enIntf)
{
    FH_SINT32 s32Ret = FH_SUCCESS;
    VO_DEV VoDev;
    VO_LAYER VoLayer;
    VO_PUB_ATTR_S stVoPubAttr;
    VO_VIDEO_LAYER_ATTR_S stLayerAttr;
    VO_INTF_SYNC_E enIntf = _enIntf;

    if (bIsHD) {
        SAMPLE_VO_PRT("start DHD0.");
        VoDev = SAMPLE_VO_DEV_DHD0;
        VoLayer = SAMPLE_VO_LAYER_VHD0;

        stVoPubAttr.enIntfSync = enIntf;
		if (gs_bEnableLcd == FH_TRUE) {
			stVoPubAttr.enIntfType = VO_INTF_LCD;
		}
		else{
			stVoPubAttr.enIntfType = VO_INTF_VGA|VO_INTF_HDMI;
		}
        stVoPubAttr.u32BgColor = 0; //0x00FFFFFF
        s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr);
        SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartDev failed!");

        memset(&(stLayerAttr), 0 , sizeof(VO_VIDEO_LAYER_ATTR_S));
        s32Ret = SAMPLE_COMM_VO_GetWH(stVoPubAttr.enIntfSync, \
            &stLayerAttr.stImageSize.u32Width, \
            &stLayerAttr.stImageSize.u32Height, \
            &stLayerAttr.u32DispFrmRt);
        SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_GetWH failed!");

        stLayerAttr.enPixFormat = SAMPLE_PIXEL_FORMAT;
        stLayerAttr.stDispRect.s32X       = 0;
        stLayerAttr.stDispRect.s32Y       = 0;
        stLayerAttr.stDispRect.u32Width   = stLayerAttr.stImageSize.u32Width;
        stLayerAttr.stDispRect.u32Height  = stLayerAttr.stImageSize.u32Height;

        if (gs_bEnableVhd0Single) {
            SAMPLE_VO_PRT("start single VHD0.");
            s32Ret = SAMPLE_COMM_VO_StartSingleLayer(VoLayer, &stLayerAttr, FH_TRUE);
            SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartSingleLayer failed!");
        } else if (gs_bEnableCompress) {
            SAMPLE_VO_PRT("start compressed VHD0.");
            s32Ret = SAMPLE_COMM_VO_StartCompressedLayer(VoLayer, &stLayerAttr);
            SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartCompressedLayer failed!");
        } else {
            SAMPLE_VO_PRT("start VHD0.");
            s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
            SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartLayer failed!");
        }

		if (g_bEnablePIP) {			//ENABLE_PIP
			SAMPLE_VO_PRT("start PIP.");
			VoDev = SAMPLE_VO_DEV_DHD0;
       		VoLayer = SAMPLE_VO_LAYER_VPIP;

			stLayerAttr.stDispRect.s32X 	  = 200;
			stLayerAttr.stDispRect.s32Y 	  = 200;
			stLayerAttr.stDispRect.u32Width   = 320;
        	stLayerAttr.stDispRect.u32Height  = 240;

			stLayerAttr.stImageSize.u32Width  = 320;
			stLayerAttr.stImageSize.u32Height  = 320;

            SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
			SAMPLE_COMM_VO_StartChn(VoLayer, VO_MODE_1MUX);
		}

    } else {
        SAMPLE_VO_PRT("start DSD0.");
        VoDev = SAMPLE_VO_DEV_DSD0;
        VoLayer = SAMPLE_VO_LAYER_VSD0;

        stVoPubAttr.enIntfSync = enIntf/*VO_OUTPUT_PAL*/;
        stVoPubAttr.enIntfType = VO_INTF_CVBS;
        stVoPubAttr.u32BgColor = 0;
        s32Ret = SAMPLE_COMM_VO_StartDev(VoDev, &stVoPubAttr);
        SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartDev failed!");

        memset(&(stLayerAttr), 0 , sizeof(VO_VIDEO_LAYER_ATTR_S));
        s32Ret = SAMPLE_COMM_VO_GetWH(stVoPubAttr.enIntfSync, \
            &stLayerAttr.stImageSize.u32Width, \
            &stLayerAttr.stImageSize.u32Height, \
            &stLayerAttr.u32DispFrmRt);
        SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_GetWH failed!");

        SAMPLE_VO_PRT("start VSD0.");
        stLayerAttr.enPixFormat = PIXEL_FMT_YUV_SEMIPLANAR_420;
        stLayerAttr.stDispRect.s32X       = 0;
        stLayerAttr.stDispRect.s32Y       = 0;
        stLayerAttr.stDispRect.u32Width   = stLayerAttr.stImageSize.u32Width;
        stLayerAttr.stDispRect.u32Height  = stLayerAttr.stImageSize.u32Height;
        s32Ret = SAMPLE_COMM_VO_StartLayer(VoLayer, &stLayerAttr);
        SAMPLE_VO_CHECK_GOTO((FH_SUCCESS != s32Ret), EXIT, "SAMPLE_COMM_VO_StartLayer failed!");
    }


EXIT:

    return s32Ret;
}

FH_SINT32 vo_test_exit(FH_BOOL bIsHD)
{
    FH_SINT32 s32Ret = FH_SUCCESS;
    VO_DEV VoDev;
    VO_LAYER VoLayer;


	if (g_bEnablePIP) {
		SAMPLE_VO_PRT("stop PIP.");
		VoLayer = SAMPLE_VO_LAYER_VPIP;
		SAMPLE_COMM_VO_StopLayer(VoLayer);

		SAMPLE_VO_PRT("stop PIP.");
		//VoDev = SAMPLE_VO_DEV_DHD0;
		//SAMPLE_COMM_VO_StopDev(VoDev);
	}

    if (bIsHD) {
        SAMPLE_VO_PRT("stop VHD0.");
        VoLayer = SAMPLE_VO_LAYER_VHD0;
        SAMPLE_COMM_VO_StopLayer(VoLayer);

        SAMPLE_VO_PRT("stop DHD0.");
        VoDev = SAMPLE_VO_DEV_DHD0;
        SAMPLE_COMM_VO_StopDev(VoDev);
    } else {
        SAMPLE_VO_PRT("stop VSD0.");
        VoLayer = SAMPLE_VO_LAYER_VSD0;
        SAMPLE_COMM_VO_StopLayer(VoLayer);

        SAMPLE_VO_PRT("stop DSD0.");
        VoDev = SAMPLE_VO_DEV_DSD0;
        SAMPLE_COMM_VO_StopDev(VoDev);
    }

    return s32Ret;
}

int vo_test_startlayer(int layer, int enMode)
{
    FH_SINT32 s32Ret = FH_SUCCESS;

	s32Ret = SAMPLE_COMM_VO_StartChn(layer,enMode);
	return s32Ret;
}