/*
  Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/ioctl.h>
#include <sys/prctl.h>
#include "sample_comm.h"

#define  MM16_BMP  "./res/mm16.bmp"
#define  MM_BMP        "./res/mm.bmp"
#define STREAM_PATH    "res"
#define STREAM_H265_1080P   "1080P.h265"

#define VB_NUM_PRE_CHN   8
#define RGN_VPSS_GRP     0
#define RGN_VPSS_CHN     0
#define RGN_VI_CHN       0
#define RGN_VENC_CHN     0
#define RGN_VB_BLK_SIZE_1 2
#define RGN_VB_BLK_SIZE_2 3
#define RGN_VB_BLK_CNT_1 2
#define RGN_VB_BLK_CNT_2 4
#define RGN_HANDLE_NUM_1 1
#define RGN_HANDLE_NUM_2 4
#define RGN_HANDLE_NUM_3 8

#define RGN_VO_CHN       0
#define RGN_VDEC_CHN     0
#define RGN_VDEC_CHN_NUM 1

ot_vpss_grp_attr g_vpss_grp_attr = {0};

td_char *g_path_bmp = TD_NULL;
pthread_t g_vdec_thread[RGN_VDEC_CHN_NUM];

sample_vi_param  g_rgn_vi_param;

ot_vo_intf_type          g_rgn_vo_intf_type = OT_VO_INTF_VGA | OT_VO_INTF_HDMI;

#ifdef OT_FPGA
ot_vo_intf_sync g_rgn_intf_sync = OT_VO_OUT_720P60;
sample_vi_mode g_rgn_vi_mode = SAMPLE_VI_MODE_720P_2X2;
#else
ot_vo_intf_sync g_rgn_intf_sync = OT_VO_OUT_1080P60;
sample_vi_mode g_rgn_vi_mode = SAMPLE_VI_MODE_1080P_1X2;
#endif

static sample_vdec_attr g_rgn_vdec_cfg = {
    .type = OT_PT_H265,
    .mode = OT_VDEC_SEND_MODE_FRAME,
    .width = FHD_WIDTH,
    .height = FHD_HEIGHT,
    .sample_vdec_video.dec_mode = OT_VIDEO_DEC_MODE_IP,
    .sample_vdec_video.bit_width = OT_DATA_BIT_WIDTH_8,
    .sample_vdec_video.ref_frame_num = 2, /* 2:ref_frame_num */
    .display_frame_num = 2, /* 2:display_frame_num */
    .frame_buf_cnt =5,  /* 5:2+2+1 */
};

static vdec_thread_param g_rgn_vdec_thread_param = {
    .chn_id = 0,
    .type = OT_PT_H265,
    .stream_mode = OT_VDEC_SEND_MODE_FRAME,
    .interval_time = 1000, /* 1000:interval_time */
    .pts_init = 0,
    .pts_increase = 0,
    .e_thread_ctrl = THREAD_CTRL_START,
    .circle_send = TD_TRUE,
    .milli_sec = 0,
    .min_buf_size = (FHD_WIDTH * FHD_HEIGHT * 3) >> 1, /* 3:buff_size */
    .c_file_path = "res",
    .c_file_name = STREAM_H265_1080P,
};

static sample_vo_cfg g_rgn_vo_config = {
    .vo_dev = SAMPLE_VO_DEV_DHD0,
    .vo_intf_type = OT_VO_INTF_VGA | OT_VO_INTF_HDMI,
    .intf_sync = OT_VO_OUT_1080P60,
    .disp_rect = {0, 0, FHD_WIDTH, FHD_HEIGHT},
    .image_size = {FHD_WIDTH, FHD_HEIGHT},
    .bg_color = COLOR_RGB_BLUE,
    .vo_mode = VO_MODE_1MUX,
    .pix_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420,
    .vo_part_mode = OT_VO_PARTITION_MODE_SINGLE,
    .dis_buf_len = 3, /* 3:buf len */
    .dst_dynamic_range = OT_DYNAMIC_RANGE_SDR8,
    .compress_mode = OT_COMPRESS_MODE_NONE,
};

/*
 * function : show usage
 */
static td_void sample_region_usage(const char *s_prg_nm)
{
    printf("usage : %s <index> \n", s_prg_nm);
    printf("index:\n");
    printf("\t 0)VI COVER.\n");
    printf("\t 1)VPSS OVERLAY.\n");
    printf("\t 2)VPSS OVERLAYEX.\n");
    printf("\t 3)VPSS COVEREX.\n");
    printf("\t 4)VPSS COVER.\n");
    printf("\t 5)VPSS LINE.\n");
    printf("\t 6)VPSS MOSAIC.\n");
    printf("\t 7)VPSS MOSAICEX.\n");
    printf("\t 8)VO OVERLAYEX.\n");
    printf("\t 9)VO COVEREX.\n");
    printf("\t 10)VO LINE.\n");
    printf("\t 11)VENC OVERLAY.\n");
}

static int g_rgn_sample_exit = 0;

/*
 * function: to process abnormal case
 */
static td_void sample_region_handle_sig(td_s32 signo)
{
    if ((signo == SIGINT) || (signo == SIGTERM)) {
        g_rgn_sample_exit = 1;
    }
}

static td_void sample_region_pause(td_void)
{
    if (g_rgn_sample_exit == 1) {
        return;
    }

    sample_pause();

    if (g_rgn_sample_exit == 1) {
        return;
    }
}

static td_s32 sample_region_start_venc(td_void)
{
    td_s32          ret;
    ot_venc_gop_mode gop_mode;
    ot_venc_gop_attr gop_attr;
    sample_rc     rc_mode;
    ot_pic_size      pic_size;
    sample_comm_venc_chnl_param venc_create_param = {0};

    rc_mode = SAMPLE_RC_CBR;

    gop_mode = OT_VENC_GOP_MODE_NORMAL_P;

    sample_common_vi_get_size_by_mode(g_rgn_vi_mode, &pic_size);
    ret = sample_comm_venc_get_gop_attr(gop_mode, &gop_attr);

    venc_create_param.type = OT_PT_H265;
    venc_create_param.size = pic_size;
    venc_create_param.rc_mode = rc_mode;
    venc_create_param.profile = 0;
    venc_create_param.is_rcn_ref_share_buf = 0;
    venc_create_param.gop_attr = gop_attr;

    ret = sample_comm_venc_start(0, &venc_create_param);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_venc_start_venc failed with %d!\n", ret);
        sample_comm_venc_stop(0);
    }
    return ret;
}

static td_s32 sample_region_stop_venc(td_void)
{
    sample_comm_venc_stop(RGN_VENC_CHN);
    return TD_SUCCESS;
}

static td_void sample_region_start_get_venc_stream(td_void)
{
    td_s32 venc_chn[2] = {0, 1}; /* 2:VENC chn max num */
    sample_comm_venc_start_get_stream(venc_chn, 1);
    return;
}

static td_void sample_region_stop_get_venc_stream(td_void)
{
    sample_comm_venc_stop_get_stream(1);
    return;
}

static td_s32 sample_region_mpp_start_vpss(ot_vpss_grp vpss_grp,
    td_bool *chn_enable, ot_vpss_grp_attr *vpss_grp_attr, ot_vpss_chn_attr *vpss_chn_attr)
{
    td_s32 ret;
    td_s32 j;
    ot_vpss_chn vpss_chn;

    ret = ss_mpi_vpss_create_grp(vpss_grp, vpss_grp_attr);
    if (ret != TD_SUCCESS) {
        sample_print("ss_mpi_vpss_create_grp(grp:%d) failed with %#x!\n", vpss_grp, ret);
        return TD_FAILURE;
    }
    ret = ss_mpi_vpss_start_grp(vpss_grp);
    if (ret != TD_SUCCESS) {
        sample_print("ss_mpi_vpss_start_grp failed with %#x\n", ret);
        return TD_FAILURE;
    }

    for (j = 0; j < OT_VPSS_MAX_PHYS_CHN_NUM; j++) {
        if (chn_enable[j] == TD_TRUE) {
            vpss_chn = j;
            ret = ss_mpi_vpss_set_chn_attr(vpss_grp, vpss_chn, &vpss_chn_attr[vpss_chn]);
            if (ret != TD_SUCCESS) {
                sample_print("ss_mpi_vpss_set_chn_attr failed with %#x\n", ret);
                return TD_FAILURE;
            }
            ret = ss_mpi_vpss_enable_chn(vpss_grp, vpss_chn);
            if (ret != TD_SUCCESS) {
                sample_print("ss_mpi_vpss_enable_chn failed with %#x\n", ret);
                return TD_FAILURE;
            }
        }
    }
    return TD_SUCCESS;
}

static td_s32 get_vb_attr(sample_vi_mode vi_mode)
{
    switch (vi_mode) {
        case SAMPLE_VI_MODE_720P_1X4:
        case SAMPLE_VI_MODE_960H_4X4:
        case SAMPLE_VI_MODE_720P_4X4:
            return 0;
        case SAMPLE_VI_MODE_720P_2X2:
        case SAMPLE_VI_MODE_1080P_2X2:
        case SAMPLE_VI_MODE_1080P_1X2:
        case SAMPLE_VI_MODE_4K_1X8:
            return 1;
        default:
            sample_print("vi_mode invalid !\n");
            return TD_FAILURE;
    }
}

static td_s32 sample_region_set_vb_cfg(sample_vi_mode vi_mode,
    ot_size *size, sample_vi_param *vi_param, ot_vb_cfg *vb_cfg)
{
    td_s32 vb_type;
    td_u32 blk_size;
    ot_pic_buf_attr pic_buf_attr;

    (td_void)memset_s(vb_cfg, sizeof(ot_vb_cfg), 0, sizeof(ot_vb_cfg));
    vb_type = get_vb_attr(vi_mode);
    if (vb_type == 0) {
        vb_cfg->max_pool_cnt = 2; /* 2:max_pool_cnt */
        pic_buf_attr.width = size->width;
        pic_buf_attr.height = size->height;
        pic_buf_attr.pixel_format = SAMPLE_PIXEL_FORMAT;
        pic_buf_attr.bit_width = OT_DATA_BIT_WIDTH_8;
        pic_buf_attr.compress_mode = OT_COMPRESS_MODE_SEG_COMPACT;
        pic_buf_attr.align = OT_DEFAULT_ALIGN;
        blk_size = ot_common_get_pic_buf_size(&pic_buf_attr);
        vb_cfg->common_pool[0].blk_size = blk_size * RGN_VB_BLK_SIZE_1;
        vb_cfg->common_pool[0].blk_cnt = vi_param->vi_chn_cnt * VB_NUM_PRE_CHN * RGN_VB_BLK_CNT_1;

        pic_buf_attr.compress_mode = OT_COMPRESS_MODE_NONE;
        blk_size = ot_common_get_pic_buf_size(&pic_buf_attr);
        vb_cfg->common_pool[1].blk_size = blk_size * RGN_VB_BLK_SIZE_2;
        vb_cfg->common_pool[1].blk_cnt = vi_param->vi_chn_cnt * VB_NUM_PRE_CHN * RGN_VB_BLK_CNT_1;
    } else if (vb_type == 1) {
        vb_cfg->max_pool_cnt = 3; /* 3:max_pool_cnt */
        pic_buf_attr.width = size->width;
        pic_buf_attr.height = size->height;
        pic_buf_attr.pixel_format = SAMPLE_PIXEL_FORMAT;
        pic_buf_attr.bit_width = OT_DATA_BIT_WIDTH_8;
        pic_buf_attr.compress_mode = OT_COMPRESS_MODE_SEG_COMPACT;
        pic_buf_attr.align = OT_DEFAULT_ALIGN;
        blk_size = ot_common_get_pic_buf_size(&pic_buf_attr);
        vb_cfg->common_pool[0].blk_size = blk_size;
        vb_cfg->common_pool[0].blk_cnt = RGN_VB_BLK_CNT_2 * VB_NUM_PRE_CHN;

        pic_buf_attr.compress_mode = OT_COMPRESS_MODE_NONE;
        blk_size = ot_common_get_pic_buf_size(&pic_buf_attr);
        vb_cfg->common_pool[1].blk_size = blk_size * RGN_VB_BLK_SIZE_1; /* 1:the second blk */
        vb_cfg->common_pool[1].blk_cnt = vi_param->vi_chn_cnt * VB_NUM_PRE_CHN; /* 1:the second blk */

        pic_buf_attr.width = vi_param->minor_dst_size.width;
        pic_buf_attr.width = vi_param->minor_dst_size.height;
        blk_size = ot_common_get_pic_buf_size(&pic_buf_attr);
        vb_cfg->common_pool[2].blk_size = blk_size * RGN_VB_BLK_SIZE_1; /* 2:the third blk */
        vb_cfg->common_pool[2].blk_cnt = vi_param->vi_chn_cnt * VB_NUM_PRE_CHN; /* 2:the third blk */
    }

    return TD_SUCCESS;
}

static td_s32 sample_region_start_vi(td_void)
{
    sample_video_encoding video_encoding = SAMPLE_VIDEO_ENCODING_NTSC;
    ot_vb_cfg vb_cfg;
    td_s32 ret;
    ot_size size;
    ot_pic_size pic_size;

    ret = sample_common_vi_get_size_by_mode(g_rgn_vi_mode, &pic_size);
    if (ret != TD_SUCCESS) {
        sample_print("get size by mode failed!\n");
        return ret;
    }

    ret = sample_comm_sys_get_pic_size(pic_size, &size);
    if (ret != TD_SUCCESS) {
        sample_print("get pic size failed!\n");
        return ret;
    }

    /* get parameter from vi mode */
    ret = sample_common_vi_mode_to_param(g_rgn_vi_mode, &g_rgn_vi_param);
    if (ret != TD_SUCCESS) {
        sample_print("vi get param failed!\n");
        return ret;
    }
    g_rgn_vi_param.minor_attr_en = TD_FALSE;

    ret = sample_region_set_vb_cfg(g_rgn_vi_mode, &size, &g_rgn_vi_param, &vb_cfg);
    if (ret != TD_SUCCESS) {
        sample_print("set vb config failed!\n");
        return ret;
    }

    ret = sample_comm_sys_init(&vb_cfg);
    if (ret != TD_SUCCESS) {
        sample_print("system init failed with 0x%x!\n", ret);
        sample_comm_sys_exit();
        return ret;
    }

    ret = sample_common_vi_start_vi(g_rgn_vi_mode, video_encoding, &g_rgn_vi_param);
    if (ret != TD_SUCCESS) {
        sample_print("start vi failed with 0x%x!\n", ret);
        sample_comm_sys_exit();
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 sample_region_stop_vi(td_void)
{
    td_s32 i;
    td_s32 ret;
    ot_vi_dev vi_dev;
    ot_vi_chn vi_chn;

    /* stop vi chn */
    for (i = 0; i < g_rgn_vi_param.vi_chn_cnt; i++) {
        vi_chn = i * g_rgn_vi_param.vi_chn_interval;
        ret = ss_mpi_vi_disable_chn(vi_chn);
        if (ret != TD_SUCCESS) {
            sample_print("ss_mpi_vi_disable_chn failed!\n");
            return ret;
        }
    }
    /* stop vi dev */
    for (i = 0; i < g_rgn_vi_param.vi_dev_cnt; i++) {
        vi_dev = i * g_rgn_vi_param.vi_dev_interval;
        ret = ss_mpi_vi_disable_dev(vi_dev);
        if (ret != TD_SUCCESS) {
            sample_print("ss_mpi_vi_disable_dev failed!\n");
            return ret;
        }
    }
    return TD_SUCCESS;
}

static td_s32 sample_region_start_vdec(td_u32 chn_num, sample_vdec_attr *vdec_attr)
{
    td_s32 ret;
    ot_pic_buf_attr buf_attr = {0};
    ot_vb_cfg vb_cfg;
    ot_size disp_size;
    ot_pic_size disp_pic_size = PIC_1080P;

    ret =  sample_comm_sys_get_pic_size(disp_pic_size, &disp_size);
    if (ret != TD_SUCCESS) {
        sample_print("sys get pic size fail for %#x!\n", ret);
        sample_comm_sys_exit();
        return ret;
    }
    buf_attr.align = 0;
    buf_attr.bit_width = OT_DATA_BIT_WIDTH_8;
    buf_attr.compress_mode = OT_COMPRESS_MODE_NONE;
    buf_attr.height = disp_size.height;
    buf_attr.width = disp_size.width;
    buf_attr.pixel_format = OT_PIXEL_FORMAT_YVU_SEMIPLANAR_420;

    (td_void)memset_s(&vb_cfg, sizeof(ot_vb_cfg), 0, sizeof(ot_vb_cfg));
    vb_cfg.max_pool_cnt             = 1; /* 1:vb pool cnt */
    vb_cfg.common_pool[0].blk_cnt  = 10 * RGN_VDEC_CHN_NUM; /* 10:vb blk cnt */
    vb_cfg.common_pool[0].blk_size = ot_common_get_pic_buf_size(&buf_attr);
    ret = sample_comm_sys_init(&vb_cfg);
    if (ret != TD_SUCCESS) {
        sample_print("init sys fail for %#x!\n", ret);
        sample_comm_sys_exit();
        return ret;
    }
    ret = sample_comm_vdec_init_vb_pool(chn_num, vdec_attr, OT_VDEC_MAX_CHN_NUM);
    if (ret != TD_SUCCESS) {
        sample_print("vdec init vb_pool fail\n");
        sample_comm_sys_exit();
        return ret;
    }
    ret = sample_comm_vdec_start(chn_num, vdec_attr, OT_VDEC_MAX_CHN_NUM);
    if (ret != TD_SUCCESS) {
        sample_print("vdec start fail\n");
        sample_comm_vdec_exit_vb_pool();
        sample_comm_sys_exit();
    }
    return ret;
}

static td_s32 sample_region_end_vdec(td_u32 chn_num)
{
    td_s32 ret;
    ret = sample_comm_vdec_stop(chn_num);
    if (ret != TD_SUCCESS) {
        printf("vdec stop fail\n");
        return TD_FAILURE;
    }
    sample_comm_vdec_exit_vb_pool();
    return TD_SUCCESS;
}

static td_s32 sample_region_common_start_vpss(td_s32 vpss_grp, td_s32 vpss_chn, ot_size *size)
{
    td_s32 ret;
    ot_vpss_grp_attr grp_attr;
    ot_vpss_chn_attr chn_attr[OT_VPSS_MAX_PHYS_CHN_NUM] = {0};
    td_bool chn_enable[OT_VPSS_MAX_PHYS_CHN_NUM] = {0};

    (td_void)memset_s(&grp_attr, sizeof(ot_vpss_grp_attr), 0, sizeof(ot_vpss_grp_attr));
    grp_attr.max_width  = size->width;
    grp_attr.max_height = size->height;
    grp_attr.nr_en = TD_FALSE;
    grp_attr.dci_en = TD_FALSE;
    grp_attr.ie_en = TD_FALSE;
    grp_attr.dei_mode = OT_VPSS_DEI_MODE_OFF;
    grp_attr.pixel_format = SAMPLE_PIXEL_FORMAT;
    grp_attr.frame_rate.src_frame_rate = -1;
    grp_attr.frame_rate.dst_frame_rate = -1;
    grp_attr.buf_share_en = TD_FALSE;

    (td_void)memset_s(&chn_attr[vpss_chn], sizeof(ot_vpss_chn_attr), 0, sizeof(ot_vpss_chn_attr));
    chn_enable[vpss_chn] = TD_TRUE;
    chn_attr[vpss_chn].border_en = TD_FALSE;
    chn_attr[vpss_chn].width = FHD_WIDTH;
    chn_attr[vpss_chn].height = FHD_HEIGHT;
    chn_attr[vpss_chn].chn_mode                   = OT_VPSS_CHN_MODE_AUTO;
    chn_attr[vpss_chn].compress_mode              = OT_COMPRESS_MODE_SEG;
    chn_attr[vpss_chn].pixel_format               = SAMPLE_PIXEL_FORMAT;
    chn_attr[vpss_chn].frame_rate.src_frame_rate = -1;
    chn_attr[vpss_chn].frame_rate.dst_frame_rate = -1;
    chn_attr[vpss_chn].depth                    = 0;
    chn_attr[vpss_chn].mirror_en                     = TD_FALSE;
    chn_attr[vpss_chn].flip_en                       = TD_FALSE;
    chn_attr[vpss_chn].aspect_ratio.mode        = OT_ASPECT_RATIO_NONE;

    ret = sample_region_mpp_start_vpss(vpss_grp, &chn_enable[vpss_chn], &grp_attr, &chn_attr[vpss_chn]);
    if (ret != TD_SUCCESS) {
        sample_print("failed with %#x!\n", ret);
        return TD_FAILURE;
    }
    return TD_SUCCESS;
}

static td_s32 sample_region_stop_vpss(td_void)
{
    td_s32 ret;
    td_bool chn_enable[OT_VPSS_MAX_PHYS_CHN_NUM] = {0};

    ret = sample_comm_vi_un_bind_vpss(0, RGN_VI_CHN, RGN_VPSS_GRP, RGN_VPSS_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("failed with %#x!\n", ret);
        return TD_FAILURE;
    }

    ret = sample_common_vpss_stop(RGN_VPSS_GRP, chn_enable, OT_VPSS_MAX_PHYS_CHN_NUM);
    if (ret != TD_SUCCESS) {
        sample_print("failed with %#x!\n", ret);
        return TD_FAILURE;
    }
    return TD_SUCCESS;
}

static td_s32 sample_region_start_vpss(td_void)
{
    td_s32 ret;
    ot_size size;

    size.width = FHD_WIDTH;
    size.height = FHD_HEIGHT;
    ret = sample_region_common_start_vpss(RGN_VPSS_GRP, RGN_VPSS_CHN, &size);
    if (ret != TD_SUCCESS) {
        sample_print("start vpss failed with 0x%x!\n", ret);
        return TD_FAILURE;
    }

    return TD_SUCCESS;
}

static td_s32 sample_region_mpp_vi_vpss_venc_start(td_void)
{
    td_s32 ret;

    ret = sample_region_start_vi();
    if (ret != TD_SUCCESS) {
        sample_print("start vi failed with 0x%x!\n", ret);
        goto exit_vpss;
    }
    ret = sample_region_start_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("start vpss failed with 0x%x!\n", ret);
        goto exit_vpss;
    }
    ret = sample_comm_vi_bind_vpss(0, RGN_VI_CHN, RGN_VPSS_GRP, RGN_VPSS_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("vi_bind_multi_vpss 0x%x!\n", ret);
        goto exit_vpss_bind;
    }
    ret = sample_comm_vpss_bind_venc(RGN_VPSS_GRP, RGN_VPSS_CHN, RGN_VENC_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("bind vpss venc failed!\n");
        goto bind_vpss_venc_failed;
    }
    ret = sample_region_start_venc();
    if (ret != TD_SUCCESS) {
        sample_print("start venc failed!\n");
        goto start_venc_failed;
    }
    sample_region_start_get_venc_stream();
    return ret;
bind_vpss_venc_failed:
    ret = sample_region_stop_venc();
    if (ret != TD_SUCCESS) {
        sample_print("stop venc failed!\n");
    }
start_venc_failed:
    sample_comm_vi_un_bind_vpss(0, RGN_VI_CHN, RGN_VPSS_GRP, RGN_VPSS_CHN);
exit_vpss_bind:
    ret = sample_region_stop_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("stop vpss failed!\n");
    }
exit_vpss:
    ret = sample_region_stop_vi();
    if (ret != TD_SUCCESS) {
        sample_print("stop vpss failed!\n");
    }
    return ret;
}

static td_s32 sample_region_mpp_vi_vpss_venc_end(td_void)
{
    td_s32 ret;

    sample_region_stop_get_venc_stream();
    ret = sample_comm_vpss_un_bind_venc(RGN_VPSS_GRP, RGN_VPSS_CHN, RGN_VENC_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_vpss_un_bind_venc failed!\n");
        return ret;
    }
    ret = sample_region_stop_venc();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_stop_venc failed!\n");
        return ret;
    }
    ret = sample_region_stop_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_stop_vpss failed!\n");
        return ret;
    }
    ret = sample_region_stop_vi();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_stop_vi failed!\n");
        return ret;
    }
    sample_comm_sys_exit();
    return TD_SUCCESS;
}

static td_s32 sample_region_vi_vpss_venc(td_s32 handle_num, ot_rgn_type  type, ot_mpp_chn *chn)
{
    td_s32         i;
    td_s32         ret;
    td_s32         min_handle;
    ret = sample_region_mpp_vi_vpss_venc_start();
    if (ret != TD_SUCCESS) {
        return ret;
    }
    ret = sample_comm_region_create(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_create failed!\n");
        goto exit1;
    }
    ret = sample_comm_region_attach_to_chn(handle_num, type, chn);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_attach_to_chn failed!\n");
        goto exit2;
    }
    min_handle = sample_comm_region_get_min_handle(type);
    if (type == OT_RGN_OVERLAY || type == OT_RGN_OVERLAYEX) {
        for (i = min_handle; i < min_handle + handle_num; i++) {
            ret = sample_comm_region_set_bit_map(i, g_path_bmp);
            if (ret != TD_SUCCESS) {
                sample_print("sample_comm_region_set_bit_map failed!\n");
                goto exit2;
            }
        }
    }

    sample_region_pause();

exit2:
    ret = sample_comm_region_detach_frm_chn(handle_num, type, chn);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_attach_to_chn failed!\n");
    }
exit1:
    ret = sample_comm_region_destroy(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_attach_to_chn failed!\n");
    }
    ret = sample_region_mpp_vi_vpss_venc_end();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_mpp_vi_vpss_venc_end failed!\n");
    }
    return ret;
}

static td_s32 sample_region_mpp_vi_vpss_vo_start(td_void)
{
    td_s32 ret;
    ret = sample_region_start_vi();
    if (ret != TD_SUCCESS) {
        sample_print("start vi failed with 0x%x!\n", ret);
        return ret;
    }
    ret = sample_region_start_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("start vpss failed with 0x%x!\n", ret);
        return ret;
    }
    ret = sample_comm_vi_bind_vpss(0, RGN_VI_CHN, RGN_VPSS_GRP, RGN_VPSS_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("vi_bind_multi_vpss 0x%x!\n", ret);
        goto EXIT_VO_DHD0;
    }
    /******************************************
      start vo DHD0 (HDMI+VGA), multi-screen, you can switch mode
    ******************************************/
    sample_comm_vo_get_def_config(&g_rgn_vo_config);
    g_rgn_vo_config.vo_dev = SAMPLE_VO_DEV_DHD0;
    g_rgn_vo_config.vo_intf_type = g_rgn_vo_intf_type;
    g_rgn_vo_config.intf_sync = g_rgn_intf_sync;
    g_rgn_vo_config.bg_color = COLOR_RGB_BLUE;
    g_rgn_vo_config.vo_mode = VO_MODE_1MUX;
    ret = sample_comm_vo_start_vo(&g_rgn_vo_config);
    if (ret != TD_SUCCESS) {
        sample_print("start vo failed with 0x%x!\n", ret);
        goto EXIT_VO_DHD0;
    }
    ret = sample_comm_vpss_bind_vo(RGN_VPSS_GRP, RGN_VPSS_CHN, SAMPLE_VO_LAYER_VHD0, 0);
    if (ret != TD_SUCCESS) {
        sample_print("vpss bind vo failed with 0x%x!\n", ret);
        goto EXIT_VO_DHD0_BIND;
    }
    return ret;
EXIT_VO_DHD0:
    sample_comm_vi_un_bind_vpss(0, RGN_VI_CHN, RGN_VPSS_GRP, RGN_VPSS_CHN);
EXIT_VO_DHD0_BIND:
    ret = sample_comm_vo_stop_vo(&g_rgn_vo_config);
    if (ret != TD_SUCCESS) {
        sample_print("stop vo failed!\n");
    }
    return ret;
}

static td_s32 sample_region_mpp_vi_vpss_vo_end(td_void)
{
    td_s32 ret;
    sample_vo_mode vo_mode = VO_MODE_1MUX;
    ot_vo_dev  vo_dev_dhd0 = SAMPLE_VO_DEV_DHD0;
    g_rgn_vo_config.vo_dev = vo_dev_dhd0;
    g_rgn_vo_config.vo_intf_type = g_rgn_vo_intf_type;
    g_rgn_vo_config.intf_sync = g_rgn_intf_sync;
    g_rgn_vo_config.bg_color = COLOR_RGB_BLUE;
    g_rgn_vo_config.vo_mode = vo_mode;
    ret = sample_comm_vo_stop_vo(&g_rgn_vo_config);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_vo_stop_vo failed!\n");
        return ret;
    }
    ret = sample_region_stop_vi();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_stop_vi failed!\n");
        return ret;
    }
    sample_comm_sys_exit();
    return ret;
}

static td_s32 sample_region_set_bmp(td_s32 handle_num, ot_rgn_type type)
{
    td_s32 min_handle, i, ret;

    min_handle = sample_comm_region_get_min_handle(type);
    if (type == OT_RGN_OVERLAY) {
        for (i = min_handle; i < min_handle + handle_num; i++) {
            ret = sample_comm_region_set_bit_map(i, g_path_bmp);
            if (ret != TD_SUCCESS) {
                sample_print("sample_comm_region_set_bit_map failed!\n");
                return ret;
            }
        }
    } else if (type == OT_RGN_OVERLAYEX) {
        for (i = min_handle; i < min_handle + handle_num; i++) {
            ret = sample_comm_region_get_up_canvas(i, g_path_bmp);
            if (ret != TD_SUCCESS) {
                sample_print("sample_comm_region_get_up_canvas failed!\n");
                return ret;
            }
        }
    }
    return TD_SUCCESS;
}

static td_s32 sample_region_vi_vpss_vo(td_s32 handle_num, ot_rgn_type type, ot_mpp_chn *chn)
{
    td_s32 ret;

    ret = sample_region_mpp_vi_vpss_vo_start();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_mpp_vi_vpss_vo_start failed!\n");
        return ret;
    }

    ret = sample_comm_region_create(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_create failed!\n");
        goto exit1;
    }

    ret = sample_comm_region_attach_to_chn(handle_num, type, chn);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_attach_to_chn failed!\n");
        goto exit2;
    }

    ret = sample_region_set_bmp(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_set_bmp failed!\n");
        goto exit2;
    }

    sample_region_pause();

exit2:
    ret = sample_comm_region_detach_frm_chn(handle_num, type, chn);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_detach_frm_chn failed!\n");
    }
exit1:
    ret = sample_comm_region_destroy(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_destroy failed!\n");
    }
    ret = sample_region_mpp_vi_vpss_vo_end();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_mpp_vi_vpss_vo_end failed!\n");
    }
    return ret;
}

static td_s32 sample_region_vdec_vpss_vo_start(td_void)
{
    td_s32 ret;

    ret = sample_region_start_vdec(RGN_VDEC_CHN_NUM, &g_rgn_vdec_cfg);
    if (ret != TD_SUCCESS) {
        sample_print("start vdec failed with 0x%x!\n", ret);
        return ret;
    }

    ret = sample_region_start_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("start vpss failed with 0x%x!\n", ret);
        goto EXIT_VDEC;
    }

    ret = sample_comm_vdec_bind_vpss(RGN_VDEC_CHN, RGN_VPSS_GRP);
    if (ret != TD_SUCCESS) {
        sample_print("vi_bind_multi_vpss 0x%x!\n", ret);
        goto EXIT_VPSS;
    }

    ret = sample_comm_vo_start_vo(&g_rgn_vo_config);
    if (ret != TD_SUCCESS) {
        sample_print("start vo failed with 0x%x!\n", ret);
        goto EXIT_VDEC_UNBIND_VPSS;
    }

    ret = sample_comm_vpss_bind_vo(RGN_VPSS_GRP, RGN_VPSS_CHN, SAMPLE_VO_LAYER_VHD0, RGN_VO_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("vpss bind vo failed with 0x%x!\n", ret);
        goto EXIT_STOP_VO;
    }

    sample_comm_vdec_start_send_stream(RGN_VDEC_CHN_NUM, &g_rgn_vdec_thread_param, &g_vdec_thread[0],
        RGN_VDEC_CHN_NUM, RGN_VDEC_CHN_NUM);
    return ret;

EXIT_STOP_VO:
    sample_comm_vdec_stop_send_stream(RGN_VDEC_CHN_NUM, &g_rgn_vdec_thread_param, &g_vdec_thread[0],
        RGN_VDEC_CHN_NUM, RGN_VDEC_CHN_NUM);
    sample_comm_vo_stop_vo(&g_rgn_vo_config);
EXIT_VDEC_UNBIND_VPSS:
    sample_comm_vdec_un_bind_vpss(RGN_VDEC_CHN, RGN_VPSS_GRP);
EXIT_VPSS:
    ret = sample_region_stop_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_stop_vpss failed with 0x%x!\n", ret);
        return ret;
    }
EXIT_VDEC:
    ret = sample_region_end_vdec(RGN_VDEC_CHN_NUM);
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_stop_vpss failed with 0x%x!\n", ret);
    }
    return ret;
}

static td_s32 sample_region_vdec_vpss_vo_end(td_void)
{
    td_s32 ret;

    ret = sample_comm_vpss_un_bind_vo(RGN_VPSS_GRP, RGN_VPSS_CHN, SAMPLE_VO_LAYER_VHD0, RGN_VO_CHN);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_vpss_un_bind_vo failed with 0x%x!\n", ret);
        return ret;
    }

    ret = sample_comm_vo_stop_vo(&g_rgn_vo_config);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_vo_stop_vo failed with 0x%x!\n", ret);
        return ret;
    }

    ret = sample_comm_vdec_un_bind_vpss(RGN_VDEC_CHN, RGN_VPSS_GRP);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_vdec_un_bind_vpss failed with 0x%x!\n", ret);
        return ret;
    }

    sample_comm_vdec_stop_send_stream(1, &g_rgn_vdec_thread_param, &g_vdec_thread[0],
        RGN_VDEC_CHN_NUM, RGN_VDEC_CHN_NUM);

    ret = sample_region_stop_vpss();
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_vdec_un_bind_vpss failed with 0x%x!\n", ret);
        return ret;
    }

    ret = sample_region_end_vdec(RGN_VDEC_CHN_NUM);
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_end_vdec failed with 0x%x!\n", ret);
        return ret;
    }

    return TD_SUCCESS;
}

static td_s32 sample_region_vdec_vpss_vo(td_s32 handle_num, ot_rgn_type  type, ot_mpp_chn *chn)
{
    td_s32 ret;

    ret = sample_region_vdec_vpss_vo_start();
    if (ret != TD_SUCCESS) {
        sample_print("sample_region_mpp_vi_vpss_vo_start failed!\n");
        return ret;
    }

    ret = sample_comm_region_create(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_create failed!\n");
        goto exit1;
    }

    ret = sample_comm_region_attach_to_chn(handle_num, type, chn);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_attach_to_chn failed!\n");
        goto exit2;
    }

    ret = sample_region_set_bmp(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_set_bmp failed!\n");
        goto exit2;
    }

    sample_region_pause();

exit2:
    ret = sample_comm_region_detach_frm_chn(handle_num, type, chn);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_detach_frm_chn failed!\n");
    }
exit1:
    ret = sample_comm_region_destroy(handle_num, type);
    if (ret != TD_SUCCESS) {
        sample_print("sample_comm_region_destroy failed!\n");
    }
    ret = sample_region_vdec_vpss_vo_end();
    return ret;
}

static td_s32 sample_region_vi_cover(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 4; /* 4:vi cover num */
    type = OT_RGN_COVER;
    chn.mod_id = OT_ID_VI;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vi_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_overlay(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 8; /* 8:vpss overlay num */
    type = OT_RGN_OVERLAY;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;
    g_path_bmp = MM_BMP;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_overlayex(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 8; /* 8:vpss overlayex num */
    type = OT_RGN_OVERLAYEX;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;
    g_path_bmp = MM_BMP;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_coverex(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 4; /* 4:vpss coverex num */
    type = OT_RGN_COVEREX;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_cover(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 4; /* 4:vpss cover num */
    type = OT_RGN_COVER;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_line(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 4; /* 4:vpss line num */
    type = OT_RGN_LINE;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_mosaic(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 4; /* 4:vpss mosaic num */
    type = OT_RGN_MOSAIC;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vpss_mosaicex(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 4; /* 4:vpss mosaic num */
    type = OT_RGN_MOSAICEX;
    chn.mod_id = OT_ID_VPSS;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vo_overlayex(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 1; /* 1:vo overlayex num */
    type = OT_RGN_OVERLAYEX;
    chn.mod_id = OT_ID_VO;
    chn.dev_id = 0;
    chn.chn_id = 0;
    g_path_bmp = MM_BMP;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vo_coverex(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 1; /* vo coverex num */
    type = OT_RGN_COVEREX;
    chn.mod_id = OT_ID_VO;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_vo_line(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 1; /* vo line num */
    type = OT_RGN_LINE;
    chn.mod_id = OT_ID_VO;
    chn.dev_id = 0;
    chn.chn_id = 0;

    return sample_region_vdec_vpss_vo(handle_num, type, &chn);
}

static td_s32 sample_region_venc_overlay(td_void)
{
    td_s32 handle_num;
    ot_rgn_type type;
    ot_mpp_chn chn;

    handle_num = 8; /* 8:venc overlay num */
    type = OT_RGN_OVERLAY;
    chn.mod_id = OT_ID_VENC;
    chn.dev_id = 0;
    chn.chn_id = 0;
    g_path_bmp = MM_BMP;

    return sample_region_vi_vpss_venc(handle_num, type, &chn);
}

static td_s32 sample_region_index_start(td_s32 index)
{
    td_s32 ret;

    switch (index) {
        case 0: /* 0 vi cover */
            ret = sample_region_vi_cover();
            break;
        case 1: /* 1 vpss overlay */
            ret = sample_region_vpss_overlay();
            break;
        case 2: /* 2 vpss overlayex */
            ret = sample_region_vpss_overlayex();
            break;
        case 3: /* 3 vpss coverex */
            ret = sample_region_vpss_coverex();
            break;
        case 4: /* 4 vpss cover */
            ret = sample_region_vpss_cover();
            break;
        case 5: /* 5 vpss line */
            ret = sample_region_vpss_line();
            break;
        case 6: /* 6 vpss mosaic */
            ret = sample_region_vpss_mosaic();
            break;
        case 7: /* 7 vpss mosaicex */
            ret = sample_region_vpss_mosaicex();
            break;
        case 8: /* 8 vo overlayex */
            ret = sample_region_vo_overlayex();
            break;
        case 9: /* 9 vo coverex */
            ret = sample_region_vo_coverex();
            break;
        case 10: /* 10 vo line */
            ret = sample_region_vo_line();
            break;
        case 11: /* 11 venc overlay */
            ret = sample_region_venc_overlay();
            break;
        default:
            sample_print("the index(%d) is invalid!\n", index);
            return TD_FAILURE;
    }

    return ret;
}

static td_s32 sample_region_get_argv_val(char *argv[], td_u32 index, td_slong *val)
{
    td_char *end_ptr = TD_NULL;
    td_slong result;

    errno = 0;
    result = strtol(argv[index], &end_ptr, 10);  /* 10:base */
    if ((end_ptr == argv[index]) || (*end_ptr != '\0')) {
        return TD_FAILURE;
    } else if (((result == LONG_MIN) || (result == LONG_MAX)) &&
        (errno == ERANGE)) {
        return TD_FAILURE;
    }

    *val = result;
    return TD_SUCCESS;
}

#ifdef __LITEOS__
int app_main(int argc, char *argv[])
#else
int main(int argc, char *argv[])
#endif
{
    td_s32 ret = TD_FAILURE;
    td_s32 index;
    td_slong result = 0;
    struct sigaction sa;

    if (argc != 2) { /* 2: arg num */
        sample_region_usage(argv[0]);
        return TD_FAILURE;
    }

    if (strncmp(argv[1], "-h", 2) == 0) { /* 2: arg num */
        sample_region_usage(argv[0]);
        return TD_SUCCESS;
    }

#ifndef __LITEOS__
    (td_void)memset_s(&sa, sizeof(struct sigaction), 0, sizeof(struct sigaction));
    sa.sa_handler = sample_region_handle_sig;
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
#endif

    ret = sample_region_get_argv_val(argv, 1, &result);
    if (ret != TD_SUCCESS) {
        sample_print("the index is invalid!\n");
        sample_region_usage(argv[0]);
        return ret;
    }

    if ((result < 0) || (result > 11)) { /* 11:max index */
        sample_print("the index(%ld) is invalid!\n", result);
        sample_region_usage(argv[0]);
        return TD_FAILURE;
    }

    index = (td_s32)result;
    ret = sample_region_index_start(index);
    if ((ret == TD_SUCCESS) && (g_rgn_sample_exit == 0)) {
        sample_print("program exit normally!\n");
    } else {
        sample_print("program exit abnormally!\n");
    }

    return ret;
}