/*
 * Copyright (c) Hisilicon Technologies Co., Ltd. 2019-2020. All rights reserved.
 * Description: external use
 * Author: Hisilicon
 * Create: 2019-06-28
 * Notes:
 */

#include <string.h>
#include <stdint.h>
#include <math.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <pthread.h>

#include "drv_video_ext.h"
#include "mpi_win_ext.h"
#include "mpi_rm_ext.h"
#include "mpi_policy_ext.h"
#include "drv_ioctl_win.h"

#include "soc_errno.h"
#include "securec.h"

#ifdef __cplusplus
#if __cplusplus
extern "C" {
#endif
#endif

#define SOC_DEV_VO_NAME  "soc_vo"
#define VO_DEV_NAME "/dev/" SOC_DEV_VO_NAME
#undef LOG_MODULE_ID
#define LOG_MODULE_ID SOC_ID_WIN

static td_s32 g_vo_dev_fd = -1;
static pthread_mutex_t g_vo_mutex = PTHREAD_MUTEX_INITIALIZER;

#define ext_vo_lock()   (void)pthread_mutex_lock(&g_vo_mutex)
#define ext_vo_unlock() (void)pthread_mutex_unlock(&g_vo_mutex)

#define check_vo_init()                      \
    do {                                     \
        ext_vo_lock();                        \
        if (g_vo_dev_fd < 0) {               \
            ext_err_win("VO is not init.\n"); \
            ext_vo_unlock();                  \
            return SOC_ERR_VO_NO_INIT;        \
        }                                    \
        ext_vo_unlock();                      \
    } while (0)

#define check_vo_null_ptr(a)                \
    do {                                    \
        if ((a) == NULL) {                  \
            ext_err_win("para  is null.\n"); \
            return SOC_ERR_VO_NULL_PTR;      \
        }                                   \
    } while (0)

#define check_vo_handle(handle)               \
    do {                                      \
        if ((handle) == TD_INVALID_HANDLE) {  \
            ext_err_win("para is invalid.\n"); \
            return SOC_ERR_VO_INVALID_PARA;    \
        }                                     \
    } while (0)

#define check_vo_bool(b_enable)                                              \
{                                                                            \
    do {                                                                     \
        if (((b_enable) != TD_TRUE) && ((b_enable) != TD_FALSE)) {          \
            ext_err_win("b_enable=%d\n", (b_enable));                        \
            return SOC_ERR_VO_INVALID_PARA;                                  \
        }                                                                    \
    } while (0);                                                             \
}

static module_func_info g_module_func[MODULE_ID_MAX] = {{ 0 }, };

td_s32 ext_mpi_win_extern_register(const td_u32 module_id, const win_extern_func *func)
{
    if (module_id >= MODULE_ID_MAX) {
        ext_err_win("module id(0x%x) is error\n", module_id);
        return TD_FAILURE;
    }
    check_vo_null_ptr(func);
    ext_vo_lock();
    if (g_module_func[module_id].is_register == TD_TRUE) {
        ext_err_win("module id(0x%x) is registered.\n", module_id);
        ext_vo_unlock();
        return TD_FAILURE;
    }

    g_module_func[module_id].id = module_id;
    g_module_func[module_id].func = *func;
    g_module_func[module_id].is_register = TD_TRUE;

    ext_vo_unlock();
    return TD_SUCCESS;
}

td_s32 ext_mpi_win_extern_unregister(const td_u32 module_id)
{
    if (module_id >= MODULE_ID_MAX) {
        ext_err_win("module id(0x%x) is error\n", module_id);
        return TD_FAILURE;
    }

    ext_vo_lock();

    if (g_module_func[module_id].is_register == TD_FALSE) {
        ext_err_win("module id(0x%x) is unregistered.\n", module_id);
        ext_vo_unlock();
        return TD_FAILURE;
    }

    g_module_func[module_id].is_register = TD_FALSE;
    g_module_func[module_id].id = MODULE_ID_MAX;
    g_module_func[module_id].func.src_attach_window = TD_NULL;
    g_module_func[module_id].func.src_detach_window = TD_NULL;
    g_module_func[module_id].func.hdr_alg_process = TD_NULL;
    g_module_func[module_id].func.hdr_alg_init = TD_NULL;
    g_module_func[module_id].func.hdr_alg_deinit = TD_NULL;

    ext_vo_unlock();
    return TD_SUCCESS;
}

td_s32 ext_mpi_win_extern_get_func(const td_u32 module_id, win_extern_func *func)
{
    if (module_id >= MODULE_ID_MAX) {
        ext_err_win("module id(0x%x) is error\n", module_id);
        return TD_FAILURE;
    }

    if (func == TD_NULL) {
        ext_err_win("func is null\n");
        return TD_FAILURE;
    }

    ext_vo_lock();

    if (g_module_func[module_id].is_register == TD_FALSE) {
        ext_err_win("module id(0x%x) is not registered.\n", module_id);
        ext_vo_unlock();
        return TD_FAILURE;
    }

    *func = g_module_func[module_id].func;

    ext_vo_unlock();
    return TD_SUCCESS;
}

static td_void hdr_alg_init(td_handle window)
{
    td_u32 module_id = MODULE_ID_PQ;

    if (g_module_func[module_id].func.hdr_alg_init != TD_NULL) {
        g_module_func[module_id].func.hdr_alg_init(window);
    }
    return;
}

static td_void hdr_alg_deinit(td_handle window)
{
    td_u32 module_id = MODULE_ID_PQ;

    if (g_module_func[module_id].func.hdr_alg_deinit != TD_NULL) {
        g_module_func[module_id].func.hdr_alg_deinit(window);
    }
    return;
}

td_s32 ext_mpi_win_init(td_void)
{
    ext_vo_lock();

    if (g_vo_dev_fd > 0) {
        ext_vo_unlock();
        return TD_SUCCESS;
    }

    g_vo_dev_fd = open(VO_DEV_NAME, O_RDWR | O_NONBLOCK, 0);
    if (g_vo_dev_fd < 0) {
        ext_fatal_win("open VO err.\n");
        ext_vo_unlock();
        return SOC_ERR_VO_DEV_OPEN_ERR;
    }

    ext_vo_unlock();

    return TD_SUCCESS;
}
td_s32 ext_mpi_win_deinit(td_void)
{
    td_s32 ret;

    ext_vo_lock();

    if (g_vo_dev_fd < 0) {
        ext_vo_unlock();
        return TD_SUCCESS;
    }

    ret = close(g_vo_dev_fd);
    if (ret != TD_SUCCESS) {
        ext_fatal_win("close failed, ret=0x%x.\n", ret);
        ext_vo_unlock();
        return SOC_ERR_VO_DEV_CLOSE_ERR;
    }

    g_vo_dev_fd = -1;

    ext_vo_unlock();
    return TD_SUCCESS;
}

static td_s32 mpi_win_attr_check(const ext_drv_win_attr *win_attr)
{
    if (win_attr->disp >= EXT_DRV_DISPLAY_2 && win_attr->is_virtual == TD_FALSE) {
        ext_err_win("para win_attr->disp is invalid, disp = %d.\n", win_attr->disp);
        return SOC_ERR_VO_INVALID_PARA;
    }

    if (win_attr->aspect_ratio_mode >= EXT_DRV_ASP_RAT_MODE_MAX) {
        ext_err_win("para win_attr->enARCvrs is invalid, enARCvrs = %d.\n", win_attr->aspect_ratio_mode);
        return SOC_ERR_VO_INVALID_PARA;
    }

    if (win_attr->data_format >= EXT_DRV_PIXEL_MAX) {
        ext_err_win("para win_attr->enDataFormat is invalid, fmt = %d.\n", win_attr->data_format);
        return SOC_ERR_VO_INVALID_PARA;
    }

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_create(const ext_drv_win_attr *win_attr, td_handle *win)
{
    td_s32 ret;
    win_create vo_win_create;

    check_vo_null_ptr(win_attr);
    check_vo_null_ptr(win);
    check_vo_init();
    check_vo_bool(win_attr->hdr);

    ret = mpi_win_attr_check(win_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("mpi_win_attr_check failed, ret=0x%x.\n", ret);
        return ret;
    }
    if (win_attr->is_virtual != TD_TRUE) {
        ext_mpi_rm_acquire_window_handle();
    }
    ret = memcpy_s(&vo_win_create.win_attr, sizeof(ext_drv_win_attr), win_attr, sizeof(ext_drv_win_attr));
    if (ret != TD_SUCCESS) {
        ext_err_win("memcpy_s failed, ret=0x%x.\n", ret);
        return ret;
    }

    ret = ioctl(g_vo_dev_fd, CMD_WIN_CREATE, &vo_win_create);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_CREATE failed, ret=0x%x.\n", ret);
        return ret;
    }
    *win = vo_win_create.win_handle;
    hdr_alg_init(vo_win_create.win_handle);
    return TD_SUCCESS;
}

td_s32 ext_mpi_win_destroy(td_handle win)
{
    td_s32 ret;

    check_vo_handle(win);
    check_vo_init();

    hdr_alg_deinit(win);
    ret = ioctl(g_vo_dev_fd, CMD_WIN_DESTROY, &win);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_DESTROY failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_set_attr(td_handle win, const ext_drv_win_attr *win_attr)
{
    td_s32 ret;
    win_create vo_win_create;

    check_vo_handle(win);
    check_vo_null_ptr(win_attr);
    check_vo_bool(win_attr->hdr);

    if (win_attr->disp >= EXT_DRV_DISPLAY_BUTT) {
        ext_err_win("para win_attr->disp is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    if (win_attr->aspect_ratio_mode >= EXT_DRV_ASP_RAT_MODE_MAX) {
        ext_err_win("para win_attr->en_aspect_cvrs is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    if (win_attr->data_format >= EXT_DRV_PIXEL_MAX) {
        ext_err_win("para win_attr->data_format is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    ret = memset_s((td_void *)&vo_win_create, sizeof(win_create), 0, sizeof(win_create));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_create.win_handle = win;
    ret = memcpy_s(&vo_win_create.win_attr, sizeof(ext_drv_win_attr), win_attr, sizeof(ext_drv_win_attr));
    if (ret != TD_SUCCESS) {
        ext_err_win("memcpy_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ATTR, &vo_win_create);

    return ret;
}
td_s32 ext_mpi_win_get_attr(td_handle win, ext_drv_win_attr *win_attr)
{
    td_s32 ret;
    win_create vo_win_create;

    check_vo_handle(win);
    check_vo_null_ptr(win_attr);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_create, sizeof(win_create), 0, sizeof(win_create));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_create.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ATTR, &vo_win_create);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ATTR failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    ret = memcpy_s(win_attr, sizeof(ext_drv_win_attr), &vo_win_create.win_attr, sizeof(ext_drv_win_attr));
    if (ret != TD_SUCCESS) {
        ext_err_win("memcpy_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_dequeue_frame(td_handle window, ext_drv_video_frame *frame)
{
    td_s32 ret;
    win_frame vo_win_frame;

    check_vo_handle(window);
    check_vo_null_ptr(frame);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_frame, sizeof(win_frame), 0, sizeof(win_frame));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }
    vo_win_frame.win_handle = window;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_DQ_FRAME, &vo_win_frame);
    if (ret != TD_SUCCESS) {
        return ret;
    }

    *frame = vo_win_frame.frame;

    return TD_SUCCESS;
}

static td_s32 get_hdr_output_info(const ext_drv_video_frame *frame, win_xdr_frame *xdr_frame,
                                  ext_drv_source *video_source)
{
    td_s32 ret;
    win_hdr_policy_info hdr_policy_info = { 0 };

    hdr_policy_info.win_handle = xdr_frame->win_handle;
    hdr_policy_info.frame_type = frame->hdr_type;
    hdr_policy_info.frame_color_space = frame->color_space;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_HDR_OUTPUT_INFO, &hdr_policy_info);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_HDR_OUTPUT_INFO failed, win_handle=0x%x, ret=0x%x.\n",
                    xdr_frame->win_handle, ret);
        return ret;
    }

    xdr_frame->disp_out_type = hdr_policy_info.disp_outtype;
    xdr_frame->xdr_engine = hdr_policy_info.xdr_engine;
    xdr_frame->disp_output_colorspace = hdr_policy_info.disp_output_colorspace;
    xdr_frame->display_maximum_luminance = hdr_policy_info.display_maximum_luminance;
    xdr_frame->display_minimum_luminance = hdr_policy_info.display_minimum_luminance;
    *video_source = hdr_policy_info.video_source;

    return TD_SUCCESS;
}

static td_void get_hdr_alg_info_from_kernel(const ext_drv_video_frame *frame, win_xdr_frame *xdr_frame,
    ext_drv_source *video_source)
{
    td_s32 ret;

    xdr_frame->disp_out_type = EXT_DRV_DISP_TYPE_NORMAL;
    xdr_frame->xdr_engine = DRV_XDR_ENGINE_AUTO;
    if ((frame->hdr_type == EXT_DRV_HDR_TYPE_SDR) ||
        (frame->hdr_type == EXT_DRV_HDR_TYPE_HDR10) ||
        (frame->hdr_type == EXT_DRV_HDR_TYPE_HLG)) {
        return;
    }

    ret = get_hdr_output_info(frame, xdr_frame, video_source);
    if (ret != TD_SUCCESS) {
        ext_err_win("get_hdr_output_info failed, win_handle=0x%x, ret=0x%x.\n", xdr_frame->win_handle, ret);
        return;
    }

    return;
}
static td_void hdr_alg_process(const ext_drv_video_frame *frame, win_xdr_frame *xdr_frame,
    ext_drv_source video_source)
{
    td_s32 ret = TD_SUCCESS;
    td_u32 module_id = MODULE_ID_PQ;
    win_hdr_alg_input hdr_alg_input = { 0 };
    win_hdr_alg_output hdr_alg_output = { 0 };
    fn_hdr_alg_process pq_hdr_alg_process = g_module_func[module_id].func.hdr_alg_process;

    hdr_alg_input.win_handle = xdr_frame->win_handle;
    hdr_alg_input.frame = (ext_drv_video_frame *)frame;
    hdr_alg_input.disp_outtype = xdr_frame->disp_out_type;
    hdr_alg_input.disp_output_colorspace = xdr_frame->disp_output_colorspace;
    hdr_alg_input.video_source = video_source;
    hdr_alg_input.display_maximum_luminance = xdr_frame->display_maximum_luminance;
    hdr_alg_input.display_minimum_luminance = xdr_frame->display_minimum_luminance;
    if ((pq_hdr_alg_process != TD_NULL) &&
        (frame->hdr_type != EXT_DRV_HDR_TYPE_DOLBYVISION) &&
        (frame->hdr_type != EXT_DRV_HDR_TYPE_JTP_SL_HDR)) {
        ret = pq_hdr_alg_process(&hdr_alg_input, &hdr_alg_output);
    } else {
        xdr_frame->hdr_alg_result_data.data_addr = TD_NULL;
        xdr_frame->hdr_alg_result_data.total_len = 0;
    }

    if (ret != TD_SUCCESS) {
        xdr_frame->hdr_alg_result_data.data_addr = TD_NULL;
        xdr_frame->hdr_alg_result_data.total_len = 0;
        ext_err_win("hdr_alg_process failed, win_handle=0x%x, hdr_type=%d, ret=0x%x.\n",
                    xdr_frame->win_handle, frame->hdr_type, ret);
        return;
    }
    xdr_frame->hdr_alg_result_data.data_addr = hdr_alg_output.alg_data_vir_addr;
    xdr_frame->hdr_alg_result_data.video_alg_len = hdr_alg_output.video_alg_data_size;
    xdr_frame->hdr_alg_result_data.graphic_alg_len = hdr_alg_output.graphic_alg_data_size;
    xdr_frame->hdr_alg_result_data.total_len =
        hdr_alg_output.video_alg_data_size + hdr_alg_output.graphic_alg_data_size;

    return;
}

td_s32 ext_mpi_win_queue_frame(td_handle window, ext_drv_video_frame *frame, td_u32 *fence_fd)
{
    td_s32 ret;
    win_xdr_frame xdr_frame;
    ext_drv_source video_source = EXT_DRV_SOURCE_MEDIA;

    ret = memset_s(&xdr_frame, sizeof(win_xdr_frame), 0x0, sizeof(win_xdr_frame));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }

    check_vo_handle(window);
    check_vo_null_ptr(frame);
    check_vo_init();

    xdr_frame.win_handle = window;
    xdr_frame.enhance_valid = TD_FALSE;
    xdr_frame.base_frame = *frame;

    if (fence_fd == TD_NULL) {
        xdr_frame.fence_fd = 0x0;
    } else {
        xdr_frame.fence_fd = 0xffffffff;
    }

    get_hdr_alg_info_from_kernel(frame, &xdr_frame, &video_source);
    hdr_alg_process(frame, &xdr_frame, video_source);

    ret = ioctl(g_vo_dev_fd, CMD_WIN_QU_FRAME, &xdr_frame);
    if (ret == TD_SUCCESS) {
        if (fence_fd != TD_NULL) {
            *fence_fd = (td_u32)xdr_frame.fence_fd;
        }
    } else {
        if (frame->source_fence > 0) {
            frame->source_fence = -1;
            ext_err_win("ext_mpi_win_queue_frame failed , release fence, set source fence -1\n");
        }
    }

    return ret;
}

td_s32 ext_mpi_win_set_source(td_handle win, const ext_drv_win_src_handle *src)
{
    td_s32 ret;
    win_source vo_win_attach = { 0 };

    check_vo_handle(win);
    check_vo_null_ptr(src);
    check_vo_init();

    vo_win_attach.win_handle = win;
    vo_win_attach.src_info = *src;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_SOURCE, &vo_win_attach);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_SOURCE failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_source(td_handle win, ext_drv_win_src_handle *src)
{
    td_s32 ret;
    win_source vo_win_attach = { 0 };

    check_vo_handle(win);
    check_vo_null_ptr(src);
    check_vo_init();

    vo_win_attach.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_SOURCE, &vo_win_attach);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_SOURCE failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }
    *src = vo_win_attach.src_info;

    return ret;
}

td_s32 ext_mpi_win_set_enable(td_handle win, td_bool enable)
{
    td_s32 ret;
    win_enable vo_win_enable = { 0 };

    check_vo_handle(win);

    if ((enable != TD_TRUE) && (enable != TD_FALSE)) {
        ext_err_win("para enable is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    vo_win_enable.win_handle = win;
    vo_win_enable.is_enable = enable;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ENABLE, &vo_win_enable);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_ENABLE failed, win_handle=0x%x, enable=%d, ret=0x%x.\n", win, enable, ret);
    }

    return ret;
}
td_s32 ext_mpi_win_get_enable(td_handle win, td_bool *enable)
{
    td_s32 ret;
    win_enable vo_win_enable;

    check_vo_handle(win);
    check_vo_null_ptr(enable);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_enable, sizeof(win_enable), 0, sizeof(win_enable));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_enable.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ENABLE, &vo_win_enable);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ENABLE failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    *enable = vo_win_enable.is_enable;

    return ret;
}

td_s32 ext_mpi_win_set_zorder(td_handle win, ext_drv_disp_zorder zflag)
{
    td_s32 ret;
    win_zorder vo_win_zorder;

    check_vo_handle(win);
    check_vo_init();

    if (zflag >= EXT_DRV_DISP_ZORDER_BUTT) {
        ext_err_win("para zflag is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    vo_win_zorder.win_handle = win;
    vo_win_zorder.zflag = zflag;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ZORDER, &vo_win_zorder);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_ZORDER failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}
td_s32 ext_mpi_win_get_zorder(td_handle win, td_u32 *zorder)
{
    td_s32 ret;
    win_order vo_win_order;

    check_vo_handle(win);
    check_vo_null_ptr(zorder);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_order, sizeof(win_order), 0, sizeof(win_order));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_order.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ORDER, &vo_win_order);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ORDER failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    *zorder = vo_win_order.order;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_abs_zorder(td_handle win_handle, td_s32 zorder)
{
    win_abs_zorder vo_win_abs_zorder;
    td_s32 ret;

    check_vo_handle(win_handle);
    check_vo_init();

    vo_win_abs_zorder.win_handle = win_handle;
    vo_win_abs_zorder.zorder = zorder;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ABS_ZORDER, &vo_win_abs_zorder);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_ABS_ZORDER failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_abs_zorder(td_handle win_handle, td_s32 *zorder)
{
    td_s32 ret;
    win_abs_zorder vo_win_abs_zorder;

    check_vo_handle(win_handle);
    check_vo_null_ptr(zorder);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_abs_zorder, sizeof(win_abs_zorder), 0, sizeof(win_abs_zorder));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return ret;
    }

    vo_win_abs_zorder.win_handle = win_handle;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ABS_ZORDER, &vo_win_abs_zorder);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ABS_ZORDER failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return ret;
    }

    *zorder = vo_win_abs_zorder.zorder;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_freeze(td_handle win, ext_drv_win_freeze_mode win_freeze_mode)
{
    td_s32 ret;
    win_freeze vo_win_freeze;

    check_vo_handle(win);
    if (win_freeze_mode >= EXT_DRV_WIN_FREEZE_MAX) {
        ext_err_win("para erst is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    vo_win_freeze.win_handle = win;
    vo_win_freeze.freeze_mode = win_freeze_mode;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_FREEZE, &vo_win_freeze);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_FREEZE failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_freezestat(td_handle window, ext_drv_win_freeze_mode *win_freeze_mode)
{
    td_s32 ret;
    win_freeze win_freeze;

    check_vo_handle(window);
    check_vo_null_ptr(win_freeze_mode);

    check_vo_init();

    win_freeze.win_handle = window;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_FREEZE_STATUS, &win_freeze);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_FREEZE_STATUS failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }

    *win_freeze_mode = win_freeze.freeze_mode;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_priority(td_handle window, ext_drv_win_win_priority priority)
{
    td_s32 ret;
    win_priority vo_win_priority;

    check_vo_handle(window);
    if (priority >= EXT_DRV_WIN_WIN_PRIORITY_MAX) {
        ext_err_win("para win_priority(%d) is invalid.\n", priority);
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    vo_win_priority.win_handle = window;
    vo_win_priority.priority = priority;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_PRIORITY, &vo_win_priority);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_PRIORITY failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_priority(td_handle window, ext_drv_win_win_priority *priority)
{
    td_s32 ret;
    win_priority vo_win_priority;

    check_vo_handle(window);
    check_vo_null_ptr(priority);

    check_vo_init();

    vo_win_priority.win_handle = window;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_PRIORITY, &vo_win_priority);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_PRIORITY failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }

    *priority = vo_win_priority.priority;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_reset(td_handle win, ext_drv_win_reset_mode rest)
{
    win_reset vo_win_reset;
    td_s32 ret;

    check_vo_handle(win);

    if (rest >= EXT_DRV_WIN_RESET_MAX) {
        ext_err_win("para erst is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    vo_win_reset.win_handle = win;
    vo_win_reset.reset_mode = rest;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_RESET, &vo_win_reset);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_RESET failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_pause(td_handle win, td_bool enable)
{
    win_pause vo_win_pause;
    td_s32 ret;

    check_vo_handle(win);
    if ((enable != TD_TRUE) && (enable != TD_FALSE)) {
        ext_err_win("para enable is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    vo_win_pause.win_handle = win;
    vo_win_pause.enable = enable;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_PAUSE, &vo_win_pause);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_PAUSE failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_pause_status(td_handle window, td_bool *enable)
{
    win_pause vo_win_pause;
    td_s32 ret;

    check_vo_handle(window);
    check_vo_null_ptr(enable);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_pause, sizeof(win_pause), 0, sizeof(win_pause));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }

    vo_win_pause.win_handle = window;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_PAUSE_STATUS, &vo_win_pause);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_PAUSE_STATUS failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }

    *enable = vo_win_pause.enable;

    return ret;
}

td_s32 ext_mpi_win_get_playinfo(td_handle win, ext_drv_win_play_info *playinfo)
{
    td_s32 ret;
    win_play_info win_play;

    check_vo_handle(win);
    check_vo_null_ptr(playinfo);
    check_vo_init();

    win_play.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_PLAY_INFO, &win_play);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_PLAY_INFO failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }
    *playinfo = win_play.play_info;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_crop_rect(td_handle win_handle, const ext_drv_crop_rect *crop_rect)
{
    td_s32 ret;
    win_crop_rect win_rect = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(crop_rect);
    check_vo_init();

    win_rect.win_handle = win_handle;
    win_rect.crop_rect = *crop_rect;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_CROP_RECT, &win_rect);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_CROP_RECT failed, win_handle=0x%x ret=0x%x rect [%d %d %d %d].\n",
            win_rect.win_handle, ret, win_rect.crop_rect.left_offset, win_rect.crop_rect.top_offset,
            win_rect.crop_rect.right_offset, win_rect.crop_rect.bottom_offset);
    }

    return ret;
}

td_s32 ext_mpi_win_get_crop_rect(td_handle win_handle, ext_drv_crop_rect *crop_rect)
{
    td_s32 ret;
    win_crop_rect win_rect = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(crop_rect);
    check_vo_init();

    win_rect.win_handle = win_handle;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_CROP_RECT, &win_rect);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_CROP_RECT failed, win_handle=0x%x ret=0x%x rect [%d %d %d %d].\n",
            win_rect.win_handle, ret, win_rect.crop_rect.left_offset, win_rect.crop_rect.top_offset,
            win_rect.crop_rect.right_offset, win_rect.crop_rect.bottom_offset);
        return ret;
    }

    crop_rect->left_offset = win_rect.crop_rect.left_offset;
    crop_rect->top_offset = win_rect.crop_rect.top_offset;
    crop_rect->right_offset = win_rect.crop_rect.right_offset;
    crop_rect->bottom_offset = win_rect.crop_rect.bottom_offset;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_outrect(td_handle win_handle, const ext_drv_rect *out_rect)
{
    td_s32 ret;
    win_out_rect output_rect = {0};

    check_vo_handle(win_handle);
    check_vo_null_ptr(out_rect);
    check_vo_init();

    output_rect.win_handle = win_handle;
    output_rect.rect = *out_rect;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_OUT_RECT, &output_rect);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_OUT_RECT failed, win_handle=0x%x ret=0x%x rect [%d %d %d %d].\n",
            output_rect.win_handle, ret, output_rect.rect.rect_x, output_rect.rect.rect_y,
            output_rect.rect.rect_w, output_rect.rect.rect_h);
    }

    return ret;
}

td_s32 ext_mpi_win_get_outrect(td_handle win_handle, ext_drv_rect *out_rect)
{
    td_s32 ret;
    win_out_rect output_rect = {0};

    check_vo_handle(win_handle);
    check_vo_null_ptr(out_rect);
    check_vo_init();

    output_rect.win_handle = win_handle;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_OUT_RECT, &output_rect);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_OUT_RECT failed, win_handle=0x%x ret=0x%x rect [%d %d %d %d].\n",
            output_rect.win_handle, ret, output_rect.rect.rect_x, output_rect.rect.rect_y,
            output_rect.rect.rect_w, output_rect.rect.rect_h);
        return ret;
    }

    *out_rect = output_rect.rect;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_aspect_attr(td_handle win_handle, const ext_drv_win_aspect *aspect_attr)
{
    td_s32 ret;
    win_aspect_info win_aspect_attr = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(aspect_attr);
    check_vo_init();

    win_aspect_attr.win_handle = win_handle;
    win_aspect_attr.aspect_info = *aspect_attr;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ASPECT_ATTR, &win_aspect_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_ASPECT_ATTR failed, win_handle=0x%x ret=0x%x aspect=%d nonlinear [%d %d %d].\n",
            win_aspect_attr.win_handle, ret, win_aspect_attr.aspect_info.aspect_mode,
            win_aspect_attr.aspect_info.ext_drv_win_aspect_info.nonlinear_ratio.nonlinear_enable,
            win_aspect_attr.aspect_info.ext_drv_win_aspect_info.nonlinear_ratio.src_width,
            win_aspect_attr.aspect_info.ext_drv_win_aspect_info.nonlinear_ratio.dst_width);
    }

    return ret;
}

td_s32 ext_mpi_win_get_aspect_attr(td_handle win_handle, ext_drv_win_aspect *aspect_attr)
{
    td_s32 ret;
    win_aspect_info win_aspect_attr = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(aspect_attr);
    check_vo_init();

    win_aspect_attr.win_handle = win_handle;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ASPECT_ATTR, &win_aspect_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ASPECT_ATTR failed, win_handle=0x%x ret=0x%x aspect=%d nonlinear [%d %d %d].\n",
            win_aspect_attr.win_handle, ret, win_aspect_attr.aspect_info.aspect_mode,
            win_aspect_attr.aspect_info.ext_drv_win_aspect_info.nonlinear_ratio.nonlinear_enable,
            win_aspect_attr.aspect_info.ext_drv_win_aspect_info.nonlinear_ratio.src_width,
            win_aspect_attr.aspect_info.ext_drv_win_aspect_info.nonlinear_ratio.dst_width);
        return ret;
    }

    *aspect_attr = win_aspect_attr.aspect_info;
    return ret;
}

td_s32 ext_mpi_win_set_video_rect_ratio(td_handle win_handle, const ext_drv_win_rect_ratio *video_rect_ratio)
{
    td_s32 ret;
    win_video_rect_ratio win_rect_ratio = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(video_rect_ratio);
    check_vo_init();

    win_rect_ratio.win_handle = win_handle;
    win_rect_ratio.video_rect_ratio = *video_rect_ratio;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_VIDEO_RECT_RATIO, &win_rect_ratio);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_VIDEO_RECT_RATIO failed, win_handle=0x%x ret=0x%x video_ratio [%d %d %d %d].\n",
            win_rect_ratio.win_handle, ret,
            win_rect_ratio.video_rect_ratio.x_offset, win_rect_ratio.video_rect_ratio.x_offset,
            win_rect_ratio.video_rect_ratio.width, win_rect_ratio.video_rect_ratio.height);
    }

    return ret;
}

td_s32 ext_mpi_win_get_video_rect_ratio(td_handle win_handle, ext_drv_win_rect_ratio *video_rect_ratio)
{
    td_s32 ret;
    win_video_rect_ratio win_rect_ratio = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(video_rect_ratio);
    check_vo_init();

    win_rect_ratio.win_handle = win_handle;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_VIDEO_RECT_RATIO, &win_rect_ratio);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_VIDEO_RECT_RATIO failed, win_handle=0x%x ret=0x%x video_ratio [%d %d %d %d].\n",
            win_rect_ratio.win_handle, ret,
            win_rect_ratio.video_rect_ratio.x_offset, win_rect_ratio.video_rect_ratio.x_offset,
            win_rect_ratio.video_rect_ratio.width, win_rect_ratio.video_rect_ratio.height);
        return ret;
    }

    *video_rect_ratio = win_rect_ratio.video_rect_ratio;
    return ret;
}

/* only for virtual window */
td_s32 ext_mpi_win_attach_extbuffer(td_handle win, const ext_drv_extern_buffer *ext_buffer)
{
    td_s32 ret;
    win_extbuffer_attr buffer_attr = {0};

    check_vo_handle(win);
    check_vo_null_ptr(ext_buffer);
    check_vo_init();

    buffer_attr.win = win;
    buffer_attr.ext_buffer = *ext_buffer;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_VIR_ATTACH_EXTERNBUF, &buffer_attr);

    return ret;
};

td_s32 ext_mpi_win_acquire_frame(td_handle win, ext_drv_video_frame *frame_info)
{
    td_s32 ret;
    win_frame vo_win_frame;

    check_vo_handle(win);
    check_vo_null_ptr(frame_info);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_frame, sizeof(win_frame), 0, sizeof(win_frame));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_frame.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_VIR_ACQUIRE, &vo_win_frame);
    if (ret != TD_SUCCESS) {
        return ret;
    }

    ret = memcpy_s(frame_info, sizeof(ext_drv_video_frame), &(vo_win_frame.frame), sizeof(ext_drv_video_frame));
    if (ret != TD_SUCCESS) {
        ext_err_win("memcpy_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}
td_s32 ext_mpi_win_release_frame(td_handle win, const ext_drv_video_frame *frame_info)
{
    td_s32 ret;
    win_frame vo_win_frame;

    check_vo_handle(win);
    check_vo_null_ptr(frame_info);
    check_vo_init();

    ret = memset_s((td_void *)&vo_win_frame, sizeof(win_frame), 0, sizeof(win_frame));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_frame.win_handle = win;
    vo_win_frame.frame = *frame_info;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_VIR_RELEASE, &vo_win_frame);

    return ret;
}

td_s32 ext_mpi_win_set_quick_output(td_handle win, td_bool enable)
{
    win_set_quick quick_output_attr;
    td_s32 ret;

    check_vo_handle(win);

    if ((enable != TD_TRUE) && (enable != TD_FALSE)) {
        ext_err_win("para enable is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    quick_output_attr.win = win;
    quick_output_attr.quick_enable = enable;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_QUICK, &quick_output_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_QUICK failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}


td_s32 ext_mpi_win_get_quick_output_status(td_handle win, td_bool *quick_output_enable)
{
    win_set_quick quick_output_attr;
    td_s32 ret;

    check_vo_handle(win);
    check_vo_null_ptr(quick_output_enable);
    check_vo_init();

    quick_output_attr.win = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_QUICK, &quick_output_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_QUICK failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    *quick_output_enable = quick_output_attr.quick_enable;

    return ret;
}

td_s32 ext_mpi_win_set_quickout_mode(td_handle window, ext_drv_win_quickout_mode quickout_mode)
{
    win_set_quickout_mode quickout_mode_attr;
    td_s32 ret;

    check_vo_handle(window);

    if (quickout_mode >= EXT_DRV_WIN_QUICKOUT_MAX) {
        ext_err_win("quickout mode is invalid,cur:%d max:%d.\n", quickout_mode, EXT_DRV_WIN_QUICKOUT_MAX);
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    quickout_mode_attr.quickout_mode = quickout_mode;
    quickout_mode_attr.win = window;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_QUICKOUT_MODE, &quickout_mode_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_QUICKOUT_MODE failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
    }

    return ret;
}


td_s32 ext_mpi_win_get_quickout_mode(td_handle window, ext_drv_win_quickout_mode *quickout_mode)
{
    win_set_quickout_mode quickout_mode_attr;
    td_s32 ret;

    check_vo_handle(window);
    check_vo_null_ptr(quickout_mode);
    check_vo_init();

    quickout_mode_attr.win = window;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_QUICKOUT_MODE, &quickout_mode_attr);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_QUICKOUT_MODE failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }
    *quickout_mode = quickout_mode_attr.quickout_mode;
    return ret;
}


td_s32 ext_mpi_win_set_vpss_bypass(td_handle window, td_bool bypass_enable)
{
    win_vpss_bypass bypass_info;
    td_s32 ret;

    check_vo_handle(window);

    if ((bypass_enable != TD_TRUE) && (bypass_enable != TD_FALSE)) {
        ext_err_win("para enable is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    bypass_info.win_handle = window;
    bypass_info.bypass_enable = bypass_enable;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_BYPASS, &bypass_info);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_BYPASS failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_capture_picture(td_handle win, ext_drv_video_frame *pic)
{
    td_s32 ret;
    win_capture vo_win_capture;

    check_vo_handle(win);
    check_vo_null_ptr(pic);
    check_vo_init();

    vo_win_capture.win = win;

    ret = ioctl(g_vo_dev_fd, CMD_VO_WIN_CAPTURE_START, &vo_win_capture);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_VO_WIN_CAPTURE_START failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }
    *pic = vo_win_capture.captured_pic;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_capture_picture_release(td_handle win, const ext_drv_video_frame *pic)
{
    td_s32 ret;
    win_capture vo_win_rls;

    check_vo_handle(win);
    check_vo_null_ptr(pic);
    check_vo_init();

    vo_win_rls.win = win;
    vo_win_rls.captured_pic = *pic;

    ret = ioctl(g_vo_dev_fd, CMD_VO_WIN_CAPTURE_RELEASE, &vo_win_rls);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_VO_WIN_CAPTURE_RELEASE failed, win_handle=0x%x, frame_index=%d, ret=0x%x.\n",
            win, pic->frame_index, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_set_rotation(td_handle win, ext_drv_rot_angle rotation)
{
    td_s32 ret;
    win_rotation vo_win_rotation;

    check_vo_handle(win);

    if (rotation >= EXT_DRV_ROT_ANGLE_MAX) {
        ext_err_win("invalid  param.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    vo_win_rotation.win = win;
    vo_win_rotation.rotation = rotation;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ROTATION, &vo_win_rotation);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_ROTATION failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}
td_s32 ext_mpi_win_get_rotation(td_handle win, ext_drv_rot_angle *rotation)
{
    td_s32 ret;
    win_rotation vo_win_rotation;

    check_vo_handle(win);
    check_vo_null_ptr(rotation);
    check_vo_init();

    ret = memset_s(&vo_win_rotation, sizeof(vo_win_rotation), 0x0, sizeof(vo_win_rotation));
    if (ret != TD_SUCCESS) {
        ext_err_win("memset_s failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    vo_win_rotation.win = win;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ROTATION, &vo_win_rotation);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ROTATION failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }
    *rotation = vo_win_rotation.rotation;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_flip(td_handle win, td_bool flip_hori, td_bool flip_vert)
{
    td_s32 ret;
    win_flip vo_win_flip;

    check_vo_handle(win);

    if ((flip_hori != TD_TRUE) && (flip_hori != TD_FALSE)) {
        ext_err_win("para flip_hori(%d) is invalid.\n", flip_hori);
        return SOC_ERR_VO_INVALID_PARA;
    }

    if ((flip_vert != TD_TRUE) && (flip_vert != TD_FALSE)) {
        ext_err_win("para flip_vert(%d) is invalid.\n", flip_vert);
        return SOC_ERR_VO_INVALID_PARA;
    }
    check_vo_init();

    vo_win_flip.win = win;
    vo_win_flip.flip_hori = flip_hori;
    vo_win_flip.flip_vert = flip_vert;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_FLIP, &vo_win_flip);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_FLIP failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    return TD_SUCCESS;
}
td_s32 ext_mpi_win_get_flip(td_handle win, td_bool *flip_hori, td_bool *flip_vert)
{
    td_s32 ret;
    win_flip vo_win_flip;

    check_vo_handle(win);
    check_vo_null_ptr(flip_hori);
    check_vo_null_ptr(flip_vert);
    check_vo_init();

    vo_win_flip.win = win;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_FLIP, &vo_win_flip);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_FLIP failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }
    *flip_hori = vo_win_flip.flip_hori;
    *flip_vert = vo_win_flip.flip_vert;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_get_techni_output_bright(td_s32 *techni_disp_bright)
{
    td_s32 ret;
    win_techni_disp_bright win_disp_bright = { 0 };

    check_vo_null_ptr(techni_disp_bright);

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_TECHNI_OUT_BRIGHT, &win_disp_bright);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_TECHNI_OUT_BRIGHT failed, ret=0x%x.\n", ret);
        return ret;
    }

    *techni_disp_bright = (td_s32)win_disp_bright.techni_bright;

    return TD_SUCCESS;
}

td_s32 ext_mpi_vo_set_window_alpha(td_handle win, td_u32 alpha)
{
    win_alpha win_alpha;
    td_s32 ret;

    check_vo_handle(win);
    if (alpha > 100) { /* 100 is num */
        ext_err_win("invalid alpha:%d\n", alpha);
        return SOC_ERR_VO_INVALID_PARA;
    }
    check_vo_init();

    win_alpha.win = win;
    win_alpha.alpha = alpha;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_ALPHA, &win_alpha);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_ALPHA failed, win_handle=0x%x, alpha=%d, ret=0x%x\n", win, alpha, ret);
    }

    return ret;
}

td_s32 ext_mpi_vo_get_window_alpha(td_handle win, td_u32 *alpha)
{
    win_alpha win_alpha;
    td_s32 ret;

    check_vo_handle(win);
    check_vo_null_ptr(alpha);
    check_vo_init();

    win_alpha.win = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_ALPHA, &win_alpha);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_ALPHA failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
        return ret;
    }

    *alpha = win_alpha.alpha;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_reset_first_frmstatus(td_handle win)
{
    check_vo_handle(win);
    check_vo_init();

    return ioctl(g_vo_dev_fd, CMD_WIN_RESET_FIRST_FRAME_STATUS, &win);
}

td_s32 ext_mpi_win_set_sync_info(td_handle win, ext_drv_win_sync sync_mode)
{
    win_sync win_sync_cfg;
    td_s32 ret;

    check_vo_handle(win);

    if ((sync_mode < EXT_DRV_WIN_SYNC_PLAY) || (sync_mode > EXT_DRV_WIN_SYNC_PLAY_LAST)) {
        ext_err_win("para sync mode  is invalid (%d).\n", sync_mode);
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    win_sync_cfg.win_handle = win;
    win_sync_cfg.sync_mode = sync_mode;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_SYNC, &win_sync_cfg);
    if (ret != TD_SUCCESS) {
        ext_err_win("ext_mpi_win_set_sync_info failed, win_handle=0x%x, sync_mode=%d, ret=0x%x\n",
                    win, sync_mode, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_set_play_ctrl_attr(td_handle win, const ext_drv_win_play_ctrl *window_play_ctrl)
{
    win_play_ctrl st_win_play_ctrl;
    td_s32 ret;

    check_vo_handle(win);
    check_vo_null_ptr(window_play_ctrl);
    check_vo_init();
    st_win_play_ctrl.win_handle = win;
    st_win_play_ctrl.play_ctrl_info = *window_play_ctrl;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_PLAY_CTRL, &st_win_play_ctrl);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_PLAY_CTRL failed, win_handle=0x%x, ret=0x%x.\n", win, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_play_ctrl_attr(td_handle win, ext_drv_win_play_ctrl *window_play_ctrl)
{
    win_play_ctrl st_win_play_ctrl;
    td_s32 ret;

    check_vo_handle(win);
    check_vo_null_ptr(window_play_ctrl);
    check_vo_init();

    st_win_play_ctrl.win_handle = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_PLAY_CTRL, &st_win_play_ctrl);
    if (ret == TD_SUCCESS) {
        *window_play_ctrl = st_win_play_ctrl.play_ctrl_info;
    }

    return ret;
}

td_s32 ext_mpi_win_set_tplay(td_handle win, const ext_drv_win_tplay_opt *tpaly)
{
    TD_UNUSED(win);
    TD_UNUSED(tpaly);
    return SOC_ERR_VO_WIN_UNSUPPORT;
}

td_s32 ext_mpi_win_set_frame_proginterleave_mode(td_handle win,
    ext_drv_win_forceframeprog_flag force_frame_prog_flag)
{
    win_forceframe_flag win_force_frame_flag;

    check_vo_handle(win);

    if (force_frame_prog_flag >= WIN_FRAME_FORCE_MAX) {
        ext_err_win("para frame prog interleave is invalid.\n");
        return SOC_ERR_VO_INVALID_PARA;
    }

    check_vo_init();

    win_force_frame_flag.win = win;
    win_force_frame_flag.force_frame_prog_flag = force_frame_prog_flag;

    return ioctl(g_vo_dev_fd, CMD_WIN_SET_FRAME_PROGINTER, &win_force_frame_flag);
}

td_s32 ext_mpi_win_get_frame_proginterleave_mode(td_handle win,
    ext_drv_win_forceframeprog_flag *force_frame_prog_flag)
{
    win_forceframe_flag win_force_frame_flag = { 0 };
    td_s32 ret;

    check_vo_handle(win);
    check_vo_null_ptr(force_frame_prog_flag);
    check_vo_init();

    win_force_frame_flag.win = win;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_FRAME_PROGINTER, &win_force_frame_flag);
    if (ret == TD_SUCCESS) {
        *force_frame_prog_flag = win_force_frame_flag.force_frame_prog_flag;
    }

    return ret;
}

td_s32 ext_mpi_win_set_srcframe_color_space(td_handle win, ext_drv_color_space color_space)
{
    TD_UNUSED(win);
    TD_UNUSED(color_space);
    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_low_delay(td_handle win, td_bool low_delay)
{
    TD_UNUSED(win);
    TD_UNUSED(low_delay);
    return TD_SUCCESS;
}

td_s32 ext_mpi_vo_set_multi_window_attr(ext_drv_win_attr_type attr_type, const ext_drv_win_attr *win_attr,
    td_u32 number)
{
    TD_UNUSED(attr_type);
    TD_UNUSED(win_attr);
    TD_UNUSED(number);
    return TD_SUCCESS;
}

td_s32 ext_mpi_vo_set_window_zorder_num(const td_handle win, td_u32 zorder)
{
    (td_void)(win);
    TD_UNUSED(zorder);
    return TD_SUCCESS;
}

td_s32 ext_mpi_vo_get_window_zorder_num(const td_handle win, td_u32 *zorder)
{
    (td_void)(win);
    TD_UNUSED(zorder);
    if (zorder != TD_NULL) {
        *zorder = 0;
    }
    return TD_SUCCESS;
}

td_s32 ext_mpi_win_get_handle_info(ext_drv_display disp_id, ext_drv_win_handle_info *handle_info)
{
    td_s32 ret;
    win_handle_info info = { 0 };

    if ((disp_id != EXT_DRV_DISPLAY_0) && (disp_id != EXT_DRV_DISPLAY_1)) {
        ext_warn_win("Only EXT_DRV_DISPLAY_0 or EXT_DRV_DISPLAY_1 is supported, not %d!\n", disp_id);
        return SOC_ERR_DISP_NOT_SUPPORT;
    }
    check_vo_null_ptr(handle_info);
    check_vo_init();

    info.disp = disp_id;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_HANDLE_INFO, &info);
    if (ret != TD_SUCCESS) {
        ext_warn_win("ioctl CMD_WIN_GET_HANDLE_INFO failed, disp=%d, ret=0x%x\n", disp_id, ret);
        return ret;
    }
    *handle_info = info.handle_info;
    return TD_SUCCESS;
}

static td_s32 check_color(const ext_drv_disp_color *mpi_mute_color)
{
    if (mpi_mute_color->bit_depth == EXT_DRV_PIXEL_BITWIDTH_8BIT) {
        if ((mpi_mute_color->red > 0xff) ||   /* 0xff is maximum */
            (mpi_mute_color->green > 0xff) || /* 0xff is maximum */
            (mpi_mute_color->blue > 0xff)) {  /* 0xff is maximum */
            goto TRANSFER_COLOR_FAILED;
        }
    } else if (mpi_mute_color->bit_depth == EXT_DRV_PIXEL_BITWIDTH_10BIT) {
        if ((mpi_mute_color->red > 0x3ff) ||   /* 0x3ff is maximum */
            (mpi_mute_color->green > 0x3ff) || /* 0x3ff is maximum */
            (mpi_mute_color->blue > 0x3ff)) {  /* 0x3ff is maximum */
            goto TRANSFER_COLOR_FAILED;
        }
    } else if (mpi_mute_color->bit_depth == EXT_DRV_PIXEL_BITWIDTH_12BIT) {
        if ((mpi_mute_color->red > 0xfff) ||   /* 0xfff is maximum */
            (mpi_mute_color->green > 0xfff) || /* 0xfff is maximum */
            (mpi_mute_color->blue > 0xfff)) {  /* 0xfff is maximum */
            goto TRANSFER_COLOR_FAILED;
        }
    } else if (mpi_mute_color->bit_depth == EXT_DRV_PIXEL_BITWIDTH_16BIT) {
        if ((mpi_mute_color->red > 0xffff) ||   /* 0xffff is maximum */
            (mpi_mute_color->green > 0xffff) || /* 0xffff is maximum */
            (mpi_mute_color->blue > 0xffff)) {  /* 0xffff is maximum */
            goto TRANSFER_COLOR_FAILED;
        }
    } else {
        goto TRANSFER_COLOR_FAILED;
    }
    return TD_SUCCESS;

TRANSFER_COLOR_FAILED:
    ext_err_win("Invalid mute color[bitwidth / RGB]:[%d  / %d %d %d]!\n", mpi_mute_color->bit_depth,
                mpi_mute_color->red, mpi_mute_color->green, mpi_mute_color->blue);
    return TD_FAILURE;
}

td_s32 ext_mpi_win_set_mute_color(td_handle win_handle, const ext_drv_disp_color *mpi_mute_color)
{
    td_s32 ret;
    win_mute_color mute_color;

    check_vo_handle(win_handle);
    check_vo_null_ptr(mpi_mute_color);

    if (mpi_mute_color->bit_depth >= EXT_DRV_PIXEL_BITWIDTH_MAX ||
        mpi_mute_color->bit_depth == EXT_DRV_PIXEL_BITWIDTH_DEFAULT) {
        ext_err_win("Invalid para bit_depth:%d!\n", mpi_mute_color->bit_depth);
        return TD_FAILURE;
    }

    ret = check_color(mpi_mute_color);
    if (ret != TD_SUCCESS) {
        ext_err_win("check_color failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return TD_FAILURE;
    }
    check_vo_init();

    mute_color.win_handle = win_handle;
    mute_color.mute_color = *mpi_mute_color;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_MUTE_COLOR, &mute_color);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_MUTE_COLOR failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_latest_frame(td_handle window, ext_drv_video_frame *latest_frame)
{
    td_s32 ret;
    win_frame win_get_latest_frm;

    check_vo_handle(window);
    check_vo_null_ptr(latest_frame);
    check_vo_init();

    win_get_latest_frm.win_handle = window;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_LATEST_FRAME, &win_get_latest_frm);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_LATEST_FRAME failed, win_handle=0x%x, ret=0x%x.\n", window, ret);
        return ret;
    }
    *latest_frame = win_get_latest_frm.frame;

    return TD_SUCCESS;
}

td_s32 ext_mpi_win_set_ai_result(td_handle win_handle, const ext_drv_video_frame *mpi_frame,
    const ext_drv_ai_result *ai_result)
{
    td_s32 ret;
    win_ai_result ai_result_tmp;

    check_vo_handle(win_handle);
    check_vo_null_ptr(ai_result);
    check_vo_null_ptr(mpi_frame);
    check_vo_init();

    ai_result_tmp.win_handle = win_handle;
    ai_result_tmp.ai_frame = *mpi_frame;
    ai_result_tmp.ai_result = *ai_result;

    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_AI_RESULT, &ai_result_tmp);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_AI_RESULT failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_set_video_source(td_handle win_handle, ext_drv_source source_type)
{
    td_s32 ret;
    win_video_source win_source;

    check_vo_handle(win_handle);
    if (source_type >= EXT_DRV_SOURCE_MAX) {
        ext_err_win("invalid source_type:%d, max:%d\n", source_type, EXT_DRV_SOURCE_MAX);
        return SOC_ERR_VO_INVALID_PARA;
    }

    win_source.win_handle = win_handle;
    win_source.source = source_type;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_VIDEO_SOURCE, &win_source);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_VIDEO_SOURCE failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return ret;
    }
    return ret;
}

td_s32 ext_mpi_win_get_video_source(td_handle win_handle, ext_drv_source *source_type)
{
    td_s32 ret;
    win_video_source win_source;

    check_vo_handle(win_handle);
    check_vo_null_ptr(source_type);

    win_source.win_handle = win_handle;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_VIDEO_SOURCE, &win_source);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_VIDEO_SOURCE failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return ret;
    }
    *source_type = win_source.source;
    return ret;
}

td_s32 ext_mpi_win_get_hdr_type(td_handle win_handle, ext_drv_hdr_type *hdr_type)
{
    td_s32 ret;
    ext_drv_hdr_policy_param hdr_strategy_policy = {0};

    check_vo_handle(win_handle);
    check_vo_null_ptr(hdr_type);

    ret = ext_mpi_sys_policy_get_hdr_param_by_win(win_handle, &hdr_strategy_policy);
    if (ret != TD_SUCCESS) {
        ext_err_win("ext_mpi_sys_policy_get_hdr_param_by_win failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return ret;
    }
    *hdr_type = hdr_strategy_policy.hdr_type;

    return ret;
}

td_s32 ext_mpi_win_set_eos_event(td_handle win_handle)
{
    td_s32 ret;
    check_vo_handle(win_handle);
    ret = ioctl(g_vo_dev_fd, CMD_WIN_SEND_EOS_EVENT, &win_handle);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SEND_EOS_EVENT failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_set_video_3d_type(td_handle win_handle, ext_drv_3d_type video_3d_type)
{
    td_s32 ret;
    win_video_3d_type win_3d_type = { 0 };

    check_vo_handle(win_handle);
    if (video_3d_type >= EXT_DRV_3D_MAX) {
        ext_err_win("invalid video 3d type:%d, max:%d\n", video_3d_type, EXT_DRV_3D_MAX);
        return SOC_ERR_VO_INVALID_PARA;
    }

    win_3d_type.win_handle = win_handle;
    win_3d_type.video_3d_type = video_3d_type;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_SET_VIDEO_3D_TYPE, &win_3d_type);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_SET_VIDEO_3D_TYPE failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
    }

    return ret;
}

td_s32 ext_mpi_win_get_video_3d_type(td_handle win_handle, ext_drv_3d_type *video_3d_type)
{
    td_s32 ret;
    win_video_3d_type win_3d_type = { 0 };

    check_vo_handle(win_handle);
    check_vo_null_ptr(video_3d_type);

    win_3d_type.win_handle = win_handle;
    ret = ioctl(g_vo_dev_fd, CMD_WIN_GET_VIDEO_3D_TYPE, &win_3d_type);
    if (ret != TD_SUCCESS) {
        ext_err_win("ioctl CMD_WIN_GET_VIDEO_3D_TYPE failed, win_handle=0x%x, ret=0x%x.\n", win_handle, ret);
        return ret;
    }
    *video_3d_type = win_3d_type.video_3d_type;
    return ret;
}


#ifdef __cplusplus
#if __cplusplus
}
#endif
#endif /* End of #ifdef __cplusplus */