You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1899 lines
54 KiB
1899 lines
54 KiB
/*
|
|
* 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 */
|
|
|