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.
2213 lines
68 KiB
2213 lines
68 KiB
/*
|
|
* Copyright (c) Hisilicon Technologies Co., Ltd.. 2019-2019. All rights reserved.
|
|
* Description: Huanglong VI IAPI implement.
|
|
* Author: ATV team
|
|
* Create: 2019-11-20
|
|
*/
|
|
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
|
|
#include "securec.h"
|
|
#include "mpi_vi.h"
|
|
#include "uapi_vi.h"
|
|
|
|
static td_void mpi_vi_convert_iapi_to_drv_default(const uapi_vi_attr iapi_vi_attr, ext_vi_attr *drv_vi_attr)
|
|
{
|
|
drv_vi_attr->vblank = iapi_vi_attr.vblank;
|
|
drv_vi_attr->secure = iapi_vi_attr.secure;
|
|
}
|
|
|
|
static td_void mpi_vi_convert_drv_to_iapi_default(const ext_vi_attr drv_vi_attr, uapi_vi_attr *iapi_vi_attr)
|
|
{
|
|
iapi_vi_attr->vblank = drv_vi_attr.vblank;
|
|
iapi_vi_attr->secure = drv_vi_attr.secure;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_vi_type(const uapi_vi_type iapi_vi_type, ext_vi_type *drv_vi_type)
|
|
{
|
|
switch (iapi_vi_type) {
|
|
case UAPI_VI_MAIN:
|
|
*drv_vi_type = EXT_VI_TYPE_MAIN;
|
|
break;
|
|
|
|
case UAPI_VI_SUB:
|
|
*drv_vi_type = EXT_VI_TYPE_SUB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this vi_type[%d]\n", iapi_vi_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_vi_type, *drv_vi_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_vi_type(const ext_vi_type drv_vi_type, uapi_vi_type *iapi_vi_type)
|
|
{
|
|
switch (drv_vi_type) {
|
|
case EXT_VI_TYPE_MAIN:
|
|
*iapi_vi_type = UAPI_VI_MAIN;
|
|
break;
|
|
|
|
case EXT_VI_TYPE_SUB:
|
|
*iapi_vi_type = UAPI_VI_SUB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this vi_type[%d]\n", drv_vi_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_vi_type, *iapi_vi_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_vi_intf(const uapi_vi_intf_mode iapi_vi_intf, ext_vi_intf_mode *drv_vi_intf)
|
|
{
|
|
switch (iapi_vi_intf) {
|
|
case UAPI_VI_INTF_FVHDE:
|
|
*drv_vi_intf = EXT_VI_INTF_FVHDE;
|
|
break;
|
|
|
|
case UAPI_VI_INTF_BT1120:
|
|
*drv_vi_intf = EXT_VI_INTF_BT1120;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this intf_mode[%d]\n", *drv_vi_intf);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_vi_intf, *drv_vi_intf);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_vi_intf(const ext_vi_intf_mode drv_vi_intf, uapi_vi_intf_mode *iapi_vi_intf)
|
|
{
|
|
switch (drv_vi_intf) {
|
|
case EXT_VI_INTF_FVHDE:
|
|
*iapi_vi_intf = UAPI_VI_INTF_FVHDE;
|
|
break;
|
|
|
|
case EXT_VI_INTF_BT1120:
|
|
*iapi_vi_intf = UAPI_VI_INTF_BT1120;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this intf_mode[%d]\n", drv_vi_intf);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_vi_intf, *iapi_vi_intf);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_3d_fmt(const uapi_video_frame_packing_type iapi_3d_type,
|
|
ext_drv_3d_type *drv_3d_type)
|
|
{
|
|
switch (iapi_3d_type) {
|
|
case UAPI_FRAME_PACKING_TYPE_2D:
|
|
*drv_3d_type = EXT_DRV_3D_NONE;
|
|
break;
|
|
|
|
case UAPI_FRAME_PACKING_TYPE_SIDE_BY_SIDE:
|
|
*drv_3d_type = EXT_DRV_3D_SBS_HALF;
|
|
break;
|
|
|
|
case UAPI_FRAME_PACKING_TYPE_TOP_AND_BOTTOM:
|
|
*drv_3d_type = EXT_DRV_3D_TAB;
|
|
break;
|
|
|
|
case UAPI_FRAME_PACKING_TYPE_FRAME_PACKING:
|
|
*drv_3d_type = EXT_DRV_3D_FPK;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this video_3d_type[%d]\n", iapi_3d_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_3d_type, *drv_3d_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_3d_fmt(const ext_drv_3d_type drv_3d_type,
|
|
uapi_video_frame_packing_type *iapi_3d_type)
|
|
{
|
|
switch (drv_3d_type) {
|
|
case EXT_DRV_3D_NONE:
|
|
*iapi_3d_type = UAPI_FRAME_PACKING_TYPE_2D;
|
|
break;
|
|
|
|
case EXT_DRV_3D_SBS_HALF:
|
|
*iapi_3d_type = UAPI_FRAME_PACKING_TYPE_SIDE_BY_SIDE;
|
|
break;
|
|
|
|
case EXT_DRV_3D_TAB:
|
|
*iapi_3d_type = UAPI_FRAME_PACKING_TYPE_TOP_AND_BOTTOM;
|
|
break;
|
|
|
|
case EXT_DRV_3D_FPK:
|
|
*iapi_3d_type = UAPI_FRAME_PACKING_TYPE_FRAME_PACKING;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this video_3d_type[%d]\n", drv_3d_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_3d_type, *iapi_3d_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_primary(const uapi_color_primary iapi_color_primary,
|
|
ext_drv_color_primary *drv_color_primary)
|
|
{
|
|
switch (iapi_color_primary) {
|
|
case UAPI_COLOR_PRIMARY_UNSPECIFY:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_UNSPECIFY;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_BT601_525:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_BT601_525;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_BT601_625:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_BT601_625;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_BT709:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_BT709;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_BT2020:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_BT2020;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_CIE1931_XYZ:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_CIE1931_XYZ;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_BT470_SYSM:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_BT470_SYSM;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_SMPTE_240M:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_SMPTE_240M;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_GENERIC_FILM:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_GENERIC_FILM;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_SMPTE_RP431:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_SMPTE_RP431;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_SMPTE_EG432_1:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_SMPTE_EG432_1;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_EBU_TECH_3213E:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_EBU_TECH_3213E;
|
|
break;
|
|
|
|
case UAPI_COLOR_PRIMARY_ADOBE_RGB:
|
|
*drv_color_primary = EXT_DRV_COLOR_PRIMARY_ADOBE_RGB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this color_primary[%d]\n", iapi_color_primary);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_color_primary, *drv_color_primary);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_space(const uapi_color_space iapi_color_space,
|
|
ext_drv_color_space *drv_color_space)
|
|
{
|
|
switch (iapi_color_space) {
|
|
case UAPI_COLOR_CS_YUV:
|
|
*drv_color_space = EXT_DRV_COLOR_CS_YUV;
|
|
break;
|
|
|
|
case UAPI_COLOR_CS_RGB:
|
|
*drv_color_space = EXT_DRV_COLOR_CS_RGB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this color_space[%d]\n", iapi_color_space);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_color_space, *drv_color_space);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_quantify_range(
|
|
const uapi_color_quantify_range iapi_color_quantify_range, ext_drv_color_quantify_range *drv_color_quantify_range)
|
|
{
|
|
switch (iapi_color_quantify_range) {
|
|
case UAPI_COLOR_LIMITED_RANGE:
|
|
*drv_color_quantify_range = EXT_DRV_COLOR_LIMITED_RANGE;
|
|
break;
|
|
|
|
case UAPI_COLOR_FULL_RANGE:
|
|
*drv_color_quantify_range = EXT_DRV_COLOR_FULL_RANGE;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this quantify_range[%d]\n", iapi_color_quantify_range);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_color_quantify_range, *drv_color_quantify_range);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_transfer_curve(
|
|
const uapi_color_transfer_curve iapi_color_transfer_curve, ext_drv_color_transfer_curve *drv_color_transfer_curve)
|
|
{
|
|
switch (iapi_color_transfer_curve) {
|
|
case UAPI_COLOR_TRANSFER_TYPE_GAMMA_SDR:
|
|
*drv_color_transfer_curve = EXT_DRV_COLOR_TRANSFER_TYPE_GAMMA_SDR;
|
|
break;
|
|
|
|
case UAPI_COLOR_TRANSFER_TYPE_GAMMA_HDR:
|
|
*drv_color_transfer_curve = EXT_DRV_COLOR_TRANSFER_TYPE_GAMMA_HDR;
|
|
break;
|
|
|
|
case UAPI_COLOR_TRANSFER_TYPE_PQ:
|
|
*drv_color_transfer_curve = EXT_DRV_COLOR_TRANSFER_TYPE_PQ;
|
|
break;
|
|
|
|
case UAPI_COLOR_TRANSFER_TYPE_HLG:
|
|
*drv_color_transfer_curve = EXT_DRV_COLOR_TRANSFER_TYPE_HLG;
|
|
break;
|
|
|
|
case UAPI_COLOR_TRANSFER_TYPE_XVYCC:
|
|
*drv_color_transfer_curve = EXT_DRV_COLOR_TRANSFER_TYPE_XVYCC;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this transfer_curve[%d]\n", iapi_color_transfer_curve);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_color_transfer_curve, *drv_color_transfer_curve);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_matrix_coeffs(const uapi_color_matrix_coeffs iapi_color_matrix_coeffs,
|
|
ext_drv_color_matrix_coeffs *drv_color_matrix_coeffs)
|
|
{
|
|
switch (iapi_color_matrix_coeffs) {
|
|
case UAPI_COLOR_MATRIX_COEFFS_IDENTITY:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_IDENTITY;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_UNSPECIFY:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_UNSPECIFY;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_BT601_525:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_BT601_525;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_BT601_625:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_BT601_625;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_BT709:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_BT709;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_BT2020_NON_CONSTANT:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_BT2020_NON_CONSTANT;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_BT2020_CONSTANT:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_BT2020_CONSTANT;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_BT2100_ICTCP:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_BT2100_ICTCP;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_USFCC:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_USFCC;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_SMPTE_240M:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_SMPTE_240M;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_YCGCO:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_YCGCO;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_ST2085:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_ST2085;
|
|
break;
|
|
|
|
case UAPI_COLOR_MATRIX_COEFFS_CHROMAT_NON_CONSTANT:
|
|
*drv_color_matrix_coeffs = EXT_DRV_COLOR_MATRIX_COEFFS_CHROMAT_NON_CONSTANT;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this transfer_curve[%d]\n", iapi_color_matrix_coeffs);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_color_matrix_coeffs, *drv_color_matrix_coeffs);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_description(const uapi_color_description iapi_color_description,
|
|
ext_drv_color_descript *drv_color_descript)
|
|
{
|
|
td_s32 ret;
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_primary(iapi_color_description.color_primary,
|
|
&drv_color_descript->color_primary);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_space(iapi_color_description.color_space, &drv_color_descript->color_space);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_quantify_range(iapi_color_description.quantify_range,
|
|
&drv_color_descript->quantify_range);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_transfer_curve(iapi_color_description.transfer_type,
|
|
&drv_color_descript->transfer_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_matrix_coeffs(iapi_color_description.matrix_coef,
|
|
&drv_color_descript->matrix_coef);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_primary(const ext_drv_color_primary drv_color_primary,
|
|
uapi_color_primary *iapi_color_primary)
|
|
{
|
|
switch (drv_color_primary) {
|
|
case EXT_DRV_COLOR_PRIMARY_UNSPECIFY:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_UNSPECIFY;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_BT601_525:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_BT601_525;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_BT601_625:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_BT601_625;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_BT709:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_BT709;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_BT2020:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_BT2020;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_CIE1931_XYZ:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_CIE1931_XYZ;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_BT470_SYSM:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_BT470_SYSM;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_SMPTE_240M:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_SMPTE_240M;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_GENERIC_FILM:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_GENERIC_FILM;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_SMPTE_RP431:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_SMPTE_RP431;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_SMPTE_EG432_1:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_SMPTE_EG432_1;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_EBU_TECH_3213E:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_EBU_TECH_3213E;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_PRIMARY_ADOBE_RGB:
|
|
*iapi_color_primary = UAPI_COLOR_PRIMARY_ADOBE_RGB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this color_primary[%d]\n", drv_color_primary);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_color_primary, *iapi_color_primary);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_space(const ext_drv_color_space drv_color_space,
|
|
uapi_color_space *iapi_color_space)
|
|
{
|
|
switch (drv_color_space) {
|
|
case EXT_DRV_COLOR_CS_YUV:
|
|
*iapi_color_space = UAPI_COLOR_CS_YUV;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_CS_RGB:
|
|
*iapi_color_space = UAPI_COLOR_CS_RGB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this color_space[%d]\n", *iapi_color_space);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_color_space, *iapi_color_space);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_quantify_range(
|
|
const ext_drv_color_quantify_range drv_color_quantify_range, uapi_color_quantify_range *iapi_color_quantify_range)
|
|
{
|
|
switch (drv_color_quantify_range) {
|
|
case EXT_DRV_COLOR_LIMITED_RANGE:
|
|
*iapi_color_quantify_range = UAPI_COLOR_LIMITED_RANGE;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_FULL_RANGE:
|
|
*iapi_color_quantify_range = UAPI_COLOR_FULL_RANGE;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this quantify_range[%d]\n", drv_color_quantify_range);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_color_quantify_range, *iapi_color_quantify_range);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_transfer_curve(
|
|
const ext_drv_color_transfer_curve drv_color_transfer_curve, uapi_color_transfer_curve *iapi_color_transfer_curve)
|
|
{
|
|
switch (drv_color_transfer_curve) {
|
|
case EXT_DRV_COLOR_TRANSFER_TYPE_GAMMA_SDR:
|
|
*iapi_color_transfer_curve = UAPI_COLOR_TRANSFER_TYPE_GAMMA_SDR;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_TRANSFER_TYPE_GAMMA_HDR:
|
|
*iapi_color_transfer_curve = UAPI_COLOR_TRANSFER_TYPE_GAMMA_HDR;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_TRANSFER_TYPE_PQ:
|
|
*iapi_color_transfer_curve = UAPI_COLOR_TRANSFER_TYPE_PQ;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_TRANSFER_TYPE_HLG:
|
|
*iapi_color_transfer_curve = UAPI_COLOR_TRANSFER_TYPE_HLG;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_TRANSFER_TYPE_XVYCC:
|
|
*iapi_color_transfer_curve = UAPI_COLOR_TRANSFER_TYPE_XVYCC;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this transfer_curve[%d]\n", drv_color_transfer_curve);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_color_transfer_curve, *iapi_color_transfer_curve);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_matrix_coeffs(const ext_drv_color_matrix_coeffs drv_color_matrix_coeffs,
|
|
uapi_color_matrix_coeffs *iapi_color_matrix_coeffs)
|
|
{
|
|
switch (drv_color_matrix_coeffs) {
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_IDENTITY:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_IDENTITY;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_UNSPECIFY:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_UNSPECIFY;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_BT601_525:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_BT601_525;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_BT601_625:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_BT601_625;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_BT709:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_BT709;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_BT2020_NON_CONSTANT:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_BT2020_NON_CONSTANT;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_BT2020_CONSTANT:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_BT2020_CONSTANT;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_BT2100_ICTCP:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_BT2100_ICTCP;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_USFCC:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_USFCC;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_SMPTE_240M:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_SMPTE_240M;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_YCGCO:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_YCGCO;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_ST2085:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_ST2085;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_MATRIX_COEFFS_CHROMAT_NON_CONSTANT:
|
|
*iapi_color_matrix_coeffs = UAPI_COLOR_MATRIX_COEFFS_CHROMAT_NON_CONSTANT;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this transfer_curve[%d]\n", drv_color_matrix_coeffs);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_color_matrix_coeffs, *iapi_color_matrix_coeffs);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_description(const ext_drv_color_descript drv_color_descript,
|
|
uapi_color_description *iapi_color_description)
|
|
{
|
|
td_s32 ret;
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_primary(drv_color_descript.color_primary,
|
|
&iapi_color_description->color_primary);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_space(drv_color_descript.color_space, &iapi_color_description->color_space);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_quantify_range(drv_color_descript.quantify_range,
|
|
&iapi_color_description->quantify_range);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_transfer_curve(drv_color_descript.transfer_type,
|
|
&iapi_color_description->transfer_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_matrix_coeffs(drv_color_descript.matrix_coef,
|
|
&iapi_color_description->matrix_coef);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_pix_fmt(const uapi_video_pixel_format iapi_pix_fmt,
|
|
ext_drv_pixel_format *drv_pix_fmt)
|
|
{
|
|
switch (iapi_pix_fmt) {
|
|
case UAPI_FORMAT_YUV_SEMIPLANAR_420_VU:
|
|
*drv_pix_fmt = EXT_DRV_PIXEL_FMT_NV21;
|
|
break;
|
|
|
|
case UAPI_FORMAT_YUV_SEMIPLANAR_422_VU:
|
|
*drv_pix_fmt = EXT_DRV_PIXEL_FMT_NV61_2X1;
|
|
break;
|
|
|
|
case UAPI_FORMAT_YUV_SEMIPLANAR_444_VU:
|
|
*drv_pix_fmt = EXT_DRV_PIXEL_FMT_NV42;
|
|
break;
|
|
|
|
case UAPI_FORMAT_RGB_SEMIPLANAR_444:
|
|
*drv_pix_fmt = EXT_DRV_PIXEL_FMT_NV42_RGB;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this pix_fmt[%d]\n", iapi_pix_fmt);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_pix_fmt, *drv_pix_fmt);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_pix_fmt(const ext_drv_pixel_format drv_pix_fmt,
|
|
uapi_video_pixel_format *iapi_pix_fmt)
|
|
{
|
|
switch (drv_pix_fmt) {
|
|
case EXT_DRV_PIXEL_FMT_NV21:
|
|
*iapi_pix_fmt = UAPI_FORMAT_YUV_SEMIPLANAR_420_VU;
|
|
break;
|
|
|
|
case EXT_DRV_PIXEL_FMT_NV61_2X1:
|
|
*iapi_pix_fmt = UAPI_FORMAT_YUV_SEMIPLANAR_422_VU;
|
|
break;
|
|
|
|
case EXT_DRV_PIXEL_FMT_NV42:
|
|
*iapi_pix_fmt = UAPI_FORMAT_YUV_SEMIPLANAR_444_VU;
|
|
break;
|
|
|
|
case EXT_DRV_PIXEL_FMT_NV42_RGB:
|
|
*iapi_pix_fmt = UAPI_FORMAT_RGB_SEMIPLANAR_444;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this pix_fmt[%d]\n", drv_pix_fmt);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_pix_fmt, *iapi_pix_fmt);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_bit_depth(const uapi_pixel_bit_depth iapi_bit_depth,
|
|
ext_drv_pixel_bitwidth *drv_bit_width)
|
|
{
|
|
switch (iapi_bit_depth) {
|
|
case UAPI_PIXEL_BIT_DEPTH_8BIT:
|
|
*drv_bit_width = EXT_DRV_PIXEL_BITWIDTH_8BIT;
|
|
break;
|
|
|
|
case UAPI_PIXEL_BIT_DEPTH_10BIT:
|
|
*drv_bit_width = EXT_DRV_PIXEL_BITWIDTH_10BIT;
|
|
break;
|
|
|
|
case UAPI_PIXEL_BIT_DEPTH_12BIT:
|
|
*drv_bit_width = EXT_DRV_PIXEL_BITWIDTH_12BIT;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this bit_width[%d]\n", *drv_bit_width);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_bit_depth, *drv_bit_width);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_bit_depth(const ext_drv_pixel_bitwidth drv_bit_wdith,
|
|
uapi_pixel_bit_depth *iapi_bit_depth)
|
|
{
|
|
switch (drv_bit_wdith) {
|
|
case EXT_DRV_PIXEL_BITWIDTH_8BIT:
|
|
*iapi_bit_depth = UAPI_PIXEL_BIT_DEPTH_8BIT;
|
|
break;
|
|
|
|
case EXT_DRV_PIXEL_BITWIDTH_10BIT:
|
|
*iapi_bit_depth = UAPI_PIXEL_BIT_DEPTH_10BIT;
|
|
break;
|
|
|
|
case EXT_DRV_PIXEL_BITWIDTH_12BIT:
|
|
*iapi_bit_depth = UAPI_PIXEL_BIT_DEPTH_12BIT;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this bit_width[%d]\n", drv_bit_wdith);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_bit_wdith, *iapi_bit_depth);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_hdr_type(const ext_drv_hdr_type drv_hdr_type,
|
|
uapi_hdr_type *iapi_hdr_type)
|
|
{
|
|
switch (drv_hdr_type) {
|
|
case EXT_DRV_HDR_TYPE_SDR:
|
|
*iapi_hdr_type = UAPI_HDR_TYPE_SDR;
|
|
break;
|
|
|
|
case EXT_DRV_HDR_TYPE_HDR10:
|
|
*iapi_hdr_type = UAPI_HDR_TYPE_HDR10;
|
|
break;
|
|
|
|
case EXT_DRV_HDR_TYPE_HLG:
|
|
*iapi_hdr_type = UAPI_HDR_TYPE_HLG;
|
|
break;
|
|
|
|
case EXT_DRV_HDR_TYPE_CUVA:
|
|
*iapi_hdr_type = UAPI_HDR_TYPE_CUVA;
|
|
break;
|
|
|
|
case EXT_DRV_HDR_TYPE_JTP_SL_HDR:
|
|
*iapi_hdr_type = UAPI_HDR_TYPE_JTP_SL_HDR;
|
|
break;
|
|
|
|
case EXT_DRV_HDR_TYPE_DOLBYVISION:
|
|
*iapi_hdr_type = UAPI_HDR_TYPE_DOLBYVISION;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this hdr type[%d]\n", drv_hdr_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_hdr_type, *iapi_hdr_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_scan_type(const ext_drv_sample_type drv_scan_type,
|
|
uapi_video_scan_type *iapi_scan_type)
|
|
{
|
|
switch (drv_scan_type) {
|
|
case EXT_DRV_SAMPLE_TYPE_PROGRESSIVE:
|
|
*iapi_scan_type = UAPI_VIDEO_SCAN_TYPE_PROGRESSIVE;
|
|
break;
|
|
|
|
case EXT_DRV_SAMPLE_TYPE_INTERLACE:
|
|
*iapi_scan_type = UAPI_VIDEO_SCAN_TYPE_INTERLACE;
|
|
break;
|
|
|
|
case EXT_DRV_SAMPLE_TYPE_UNKNOWN:
|
|
*iapi_scan_type = UAPI_VIDEO_SCAN_TYPE_UNKNOWN;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this type[%d]\n", drv_scan_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_scan_type, *iapi_scan_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_over_sample(const uapi_oversample iapi_over_sample,
|
|
ext_vi_oversample *drv_over_sample)
|
|
{
|
|
switch (iapi_over_sample) {
|
|
case UAPI_OVERSAMPLE_1X:
|
|
*drv_over_sample = EXT_VI_OVERSAMPLE_1X;
|
|
break;
|
|
|
|
case UAPI_OVERSAMPLE_2X:
|
|
*drv_over_sample = EXT_VI_OVERSAMPLE_2X;
|
|
break;
|
|
|
|
case UAPI_OVERSAMPLE_4X:
|
|
*drv_over_sample = EXT_VI_OVERSAMPLE_4X;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this over_sample[%d]\n", iapi_over_sample);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_over_sample, *drv_over_sample);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_over_sample(const ext_vi_oversample drv_over_sample,
|
|
uapi_oversample *iapi_over_sample)
|
|
{
|
|
switch (drv_over_sample) {
|
|
case EXT_VI_OVERSAMPLE_1X:
|
|
*iapi_over_sample = UAPI_OVERSAMPLE_1X;
|
|
break;
|
|
|
|
case EXT_VI_OVERSAMPLE_2X:
|
|
*iapi_over_sample = UAPI_OVERSAMPLE_2X;
|
|
break;
|
|
|
|
case EXT_VI_OVERSAMPLE_4X:
|
|
*iapi_over_sample = UAPI_OVERSAMPLE_4X;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this over_sample[%d]\n", drv_over_sample);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_over_sample, *iapi_over_sample);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_source_type(const uapi_video_source iapi_src_type,
|
|
ext_drv_source *drv_src_type)
|
|
{
|
|
switch (iapi_src_type) {
|
|
case UAPI_VIDEO_SOURCE_ATV:
|
|
*drv_src_type = EXT_DRV_SOURCE_ATV;
|
|
break;
|
|
|
|
case UAPI_VIDEO_SOURCE_SCART:
|
|
*drv_src_type = EXT_DRV_SOURCE_SCART;
|
|
break;
|
|
|
|
case UAPI_VIDEO_SOURCE_SVIDEO:
|
|
*drv_src_type = EXT_DRV_SOURCE_SVIDEO;
|
|
break;
|
|
|
|
case UAPI_VIDEO_SOURCE_CVBS:
|
|
*drv_src_type = EXT_DRV_SOURCE_CVBS;
|
|
break;
|
|
|
|
case UAPI_VIDEO_SOURCE_VGA:
|
|
*drv_src_type = EXT_DRV_SOURCE_VGA;
|
|
break;
|
|
|
|
case UAPI_VIDEO_SOURCE_YPBPR:
|
|
*drv_src_type = EXT_DRV_SOURCE_YPBPR;
|
|
break;
|
|
|
|
case UAPI_VIDEO_SOURCE_HDMI:
|
|
*drv_src_type = EXT_DRV_SOURCE_HDMI;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this source_type[%d]\n", iapi_src_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_src_type, *drv_src_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_source_type(const ext_drv_source drv_src_type,
|
|
uapi_video_source *iapi_src_type)
|
|
{
|
|
switch (drv_src_type) {
|
|
case EXT_DRV_SOURCE_ATV:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_ATV;
|
|
break;
|
|
|
|
case EXT_DRV_SOURCE_SCART:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_SCART;
|
|
break;
|
|
|
|
case EXT_DRV_SOURCE_SVIDEO:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_SVIDEO;
|
|
break;
|
|
|
|
case EXT_DRV_SOURCE_CVBS:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_CVBS;
|
|
break;
|
|
|
|
case EXT_DRV_SOURCE_VGA:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_VGA;
|
|
break;
|
|
|
|
case EXT_DRV_SOURCE_YPBPR:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_YPBPR;
|
|
break;
|
|
|
|
case EXT_DRV_SOURCE_HDMI:
|
|
*iapi_src_type = UAPI_VIDEO_SOURCE_HDMI;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this source_type[%d]\n", drv_src_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_src_type, *iapi_src_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_access_type(const uapi_vi_access_type iapi_access_type,
|
|
ext_vi_access_type *drv_access_type)
|
|
{
|
|
switch (iapi_access_type) {
|
|
case UAPI_VI_ACCESS_TVD:
|
|
*drv_access_type = EXT_VI_ACCESS_TVD;
|
|
break;
|
|
|
|
case UAPI_VI_ACCESS_HDDEC:
|
|
*drv_access_type = EXT_VI_ACCESS_HDDEC;
|
|
break;
|
|
|
|
case UAPI_VI_ACCESS_HDMIRX_PORT0:
|
|
*drv_access_type = EXT_VI_ACCESS_HDMIRX_PORT0;
|
|
break;
|
|
|
|
case UAPI_VI_ACCESS_HDMIRX_PORT1:
|
|
*drv_access_type = EXT_VI_ACCESS_HDMIRX_PORT1;
|
|
break;
|
|
|
|
case UAPI_VI_ACCESS_HDMIRX_PORT2:
|
|
*drv_access_type = EXT_VI_ACCESS_HDMIRX_PORT2;
|
|
break;
|
|
|
|
case UAPI_VI_ACCESS_HDMIRX_PORT3:
|
|
*drv_access_type = EXT_VI_ACCESS_HDMIRX_PORT3;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this access_type[%d]\n", iapi_access_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_access_type, *drv_access_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_access_type(const ext_vi_access_type drv_access_type,
|
|
uapi_vi_access_type *iapi_access_type)
|
|
{
|
|
switch (drv_access_type) {
|
|
case EXT_VI_ACCESS_TVD:
|
|
*iapi_access_type = UAPI_VI_ACCESS_TVD;
|
|
break;
|
|
|
|
case EXT_VI_ACCESS_HDDEC:
|
|
*iapi_access_type = UAPI_VI_ACCESS_HDDEC;
|
|
break;
|
|
|
|
case EXT_VI_ACCESS_HDMIRX_PORT0:
|
|
*iapi_access_type = UAPI_VI_ACCESS_HDMIRX_PORT0;
|
|
break;
|
|
|
|
case EXT_VI_ACCESS_HDMIRX_PORT1:
|
|
*iapi_access_type = UAPI_VI_ACCESS_HDMIRX_PORT1;
|
|
break;
|
|
|
|
case EXT_VI_ACCESS_HDMIRX_PORT2:
|
|
*iapi_access_type = UAPI_VI_ACCESS_HDMIRX_PORT2;
|
|
break;
|
|
|
|
case EXT_VI_ACCESS_HDMIRX_PORT3:
|
|
*iapi_access_type = UAPI_VI_ACCESS_HDMIRX_PORT3;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this access_type[%d]\n", drv_access_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_access_type, *iapi_access_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_color_sys(const uapi_color_sys iapi_src_type, ext_drv_color_sys *drv_src_type)
|
|
{
|
|
switch (iapi_src_type) {
|
|
case UAPI_COLOR_SYS_AUTO:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_AUTO;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_PAL:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_PAL;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_NTSC:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_NTSC;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_SECAM:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_SECAM;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_PAL_M:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_PAL_M;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_PAL_N:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_PAL_N;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_PAL_60:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_PAL_60;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_NTSC443:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_NTSC443;
|
|
break;
|
|
|
|
case UAPI_COLOR_SYS_NTSC_50:
|
|
*drv_src_type = EXT_DRV_COLOR_SYS_NTSC_50;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this color_sys[%d]\n", iapi_src_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_src_type, *drv_src_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_color_sys(const ext_drv_color_sys drv_src_type, uapi_color_sys *iapi_src_type)
|
|
{
|
|
switch (drv_src_type) {
|
|
case EXT_DRV_COLOR_SYS_AUTO:
|
|
*iapi_src_type = UAPI_COLOR_SYS_AUTO;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_PAL:
|
|
*iapi_src_type = UAPI_COLOR_SYS_PAL;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_NTSC:
|
|
*iapi_src_type = UAPI_COLOR_SYS_NTSC;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_SECAM:
|
|
*iapi_src_type = UAPI_COLOR_SYS_SECAM;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_PAL_M:
|
|
*iapi_src_type = UAPI_COLOR_SYS_PAL_M;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_PAL_N:
|
|
*iapi_src_type = UAPI_COLOR_SYS_PAL_N;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_PAL_60:
|
|
*iapi_src_type = UAPI_COLOR_SYS_PAL_60;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_NTSC443:
|
|
*iapi_src_type = UAPI_COLOR_SYS_NTSC443;
|
|
break;
|
|
|
|
case EXT_DRV_COLOR_SYS_NTSC_50:
|
|
*iapi_src_type = UAPI_COLOR_SYS_NTSC_50;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this color_sys[%d]\n", drv_src_type);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_src_type, *iapi_src_type);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_display_field_mode(const uapi_vi_display_field iapi_display_field_mode,
|
|
ext_drv_field_mode *drv_dis_play_field_mode)
|
|
{
|
|
switch (iapi_display_field_mode) {
|
|
case UAPI_VI_DISPLAY_FIELD_ALL:
|
|
*drv_dis_play_field_mode = EXT_DRV_FIELD_ALL;
|
|
break;
|
|
|
|
case UAPI_VI_DISPLAY_FIELD_TOP:
|
|
*drv_dis_play_field_mode = EXT_DRV_FIELD_TOP;
|
|
break;
|
|
|
|
case UAPI_VI_DISPLAY_FIELD_BOTTOM:
|
|
*drv_dis_play_field_mode = EXT_DRV_FIELD_BOTTOM;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this dis_play_field_mode[%d]\n", iapi_display_field_mode);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_display_field_mode, *drv_dis_play_field_mode);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_display_field_mode(const ext_drv_field_mode drv_display_field_mode,
|
|
uapi_vi_display_field *iapi_display_field_mode)
|
|
{
|
|
switch (drv_display_field_mode) {
|
|
case EXT_DRV_FIELD_ALL:
|
|
*iapi_display_field_mode = UAPI_VI_DISPLAY_FIELD_ALL;
|
|
break;
|
|
|
|
case EXT_DRV_FIELD_TOP:
|
|
*iapi_display_field_mode = UAPI_VI_DISPLAY_FIELD_TOP;
|
|
break;
|
|
|
|
case EXT_DRV_FIELD_BOTTOM:
|
|
*iapi_display_field_mode = UAPI_VI_DISPLAY_FIELD_BOTTOM;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this dis_play_field_mode[%d]\n", drv_display_field_mode);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_display_field_mode, *iapi_display_field_mode);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_picture_mode(const uapi_vi_picture_mode iapi_picture_mode,
|
|
ext_vi_picture_mode *drv_picture_mode)
|
|
{
|
|
switch (iapi_picture_mode) {
|
|
case UAPI_VI_PICTURE_MODE_VIDEO:
|
|
*drv_picture_mode = EXT_VI_PICTURE_MODE_VIDEO;
|
|
break;
|
|
|
|
case UAPI_VI_PICTURE_MODE_PC:
|
|
*drv_picture_mode = EXT_VI_PICTURE_MODE_PC;
|
|
break;
|
|
|
|
case UAPI_VI_PICTURE_MODE_GAME:
|
|
*drv_picture_mode = EXT_VI_PICTURE_MODE_GAME;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this picture_mode[%d]\n", iapi_picture_mode);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", iapi_picture_mode, *drv_picture_mode);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_picture_mode(const ext_vi_picture_mode drv_picture_mode,
|
|
uapi_vi_picture_mode *iapi_picture_mode)
|
|
{
|
|
switch (drv_picture_mode) {
|
|
case EXT_VI_PICTURE_MODE_VIDEO:
|
|
*iapi_picture_mode = UAPI_VI_PICTURE_MODE_VIDEO;
|
|
break;
|
|
|
|
case EXT_VI_PICTURE_MODE_PC:
|
|
*iapi_picture_mode = UAPI_VI_PICTURE_MODE_PC;
|
|
break;
|
|
|
|
case EXT_VI_PICTURE_MODE_GAME:
|
|
*iapi_picture_mode = UAPI_VI_PICTURE_MODE_GAME;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this picture_mode[%d]\n", drv_picture_mode);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_picture_mode, *iapi_picture_mode);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_vi_config(const uapi_vi_config *iapi_vi_config, ext_vi_config *drv_vi_config)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (iapi_vi_config == TD_NULL || drv_vi_config == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
drv_vi_config->crop_rect.rect_x = iapi_vi_config->input_rect.x;
|
|
drv_vi_config->crop_rect.rect_y = iapi_vi_config->input_rect.y;
|
|
drv_vi_config->crop_rect.rect_w = (td_s32)iapi_vi_config->input_rect.width;
|
|
drv_vi_config->crop_rect.rect_h = (td_s32)iapi_vi_config->input_rect.height;
|
|
|
|
drv_vi_config->width = iapi_vi_config->width;
|
|
drv_vi_config->height = iapi_vi_config->height;
|
|
drv_vi_config->frame_rate = iapi_vi_config->frame_rate;
|
|
|
|
drv_vi_config->interlace = iapi_vi_config->interlace;
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_sys(iapi_vi_config->color_sys, &drv_vi_config->color_sys);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_display_field_mode(iapi_vi_config->display_field, &drv_vi_config->field_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_vi_config(ext_vi_config *drv_vi_config, uapi_vi_config *iapi_vi_config)
|
|
{
|
|
td_s32 ret;
|
|
|
|
if (iapi_vi_config == TD_NULL || drv_vi_config == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
iapi_vi_config->input_rect.x = drv_vi_config->crop_rect.rect_x;
|
|
iapi_vi_config->input_rect.y = drv_vi_config->crop_rect.rect_y;
|
|
iapi_vi_config->input_rect.width = (td_u32)drv_vi_config->crop_rect.rect_w;
|
|
iapi_vi_config->input_rect.height = (td_u32)drv_vi_config->crop_rect.rect_h;
|
|
|
|
iapi_vi_config->width = drv_vi_config->width;
|
|
iapi_vi_config->height = drv_vi_config->height;
|
|
iapi_vi_config->frame_rate = drv_vi_config->frame_rate;
|
|
|
|
iapi_vi_config->interlace = drv_vi_config->interlace;
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_sys(drv_vi_config->color_sys, &iapi_vi_config->color_sys);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_display_field_mode(drv_vi_config->field_mode, &iapi_vi_config->display_field);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_vi_attr(uapi_vi_attr *iapi_vi_attr, ext_vi_attr *drv_vi_attr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_convert_iapi_to_drv_default(*iapi_vi_attr, drv_vi_attr);
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_vi_type(iapi_vi_attr->vi_type, &drv_vi_attr->vi_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_vi_intf(iapi_vi_attr->intf_mode, &drv_vi_attr->intf_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_source_type(iapi_vi_attr->source_type, &drv_vi_attr->source_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_access_type(iapi_vi_attr->access_type, &drv_vi_attr->access_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_over_sample(iapi_vi_attr->over_sample, &drv_vi_attr->over_sample);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_3d_fmt(iapi_vi_attr->video_3d_type, &drv_vi_attr->video_3d_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_color_description(iapi_vi_attr->color_description, &drv_vi_attr->color_descript);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_pix_fmt(iapi_vi_attr->pixel_format, &drv_vi_attr->pixel_format);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_bit_depth(iapi_vi_attr->bit_depth, &drv_vi_attr->bit_width);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_picture_mode(iapi_vi_attr->picture_mode, &drv_vi_attr->picture_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_vi_config(&iapi_vi_attr->vi_config, &drv_vi_attr->config);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_vi_attr(ext_vi_attr *drv_vi_attr, uapi_vi_attr *iapi_vi_attr)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_convert_drv_to_iapi_default(*drv_vi_attr, iapi_vi_attr);
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_vi_type(drv_vi_attr->vi_type, &iapi_vi_attr->vi_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_vi_intf(drv_vi_attr->intf_mode, &iapi_vi_attr->intf_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_source_type(drv_vi_attr->source_type, &iapi_vi_attr->source_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_access_type(drv_vi_attr->access_type, &iapi_vi_attr->access_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_over_sample(drv_vi_attr->over_sample, &iapi_vi_attr->over_sample);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_3d_fmt(drv_vi_attr->video_3d_type, &iapi_vi_attr->video_3d_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_description(drv_vi_attr->color_descript, &iapi_vi_attr->color_description);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_pix_fmt(drv_vi_attr->pixel_format, &iapi_vi_attr->pixel_format);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_bit_depth(drv_vi_attr->bit_width, &iapi_vi_attr->bit_depth);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_picture_mode(drv_vi_attr->picture_mode, &iapi_vi_attr->picture_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_vi_config(&drv_vi_attr->config, &iapi_vi_attr->vi_config);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_vi_pattern(const uapi_vi_pattern_info *iapi_vi_pattern,
|
|
ext_vi_pattern_info *drv_vi_pattern)
|
|
{
|
|
if (drv_vi_pattern == TD_NULL || iapi_vi_pattern == TD_NULL) {
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
switch (iapi_vi_pattern->timing_source) {
|
|
case UAPI_VI_PATTERN_TIMING_SOURCE_OFF:
|
|
drv_vi_pattern->timing_source = EXT_VI_PATTERN_TIMING_SOURCE_OFF;
|
|
break;
|
|
case UAPI_VI_PATTERN_TIMING_SOURCE_INPUT:
|
|
drv_vi_pattern->timing_source = EXT_VI_PATTERN_TIMING_SOURCE_INPUT;
|
|
break;
|
|
case UAPI_VI_PATTERN_TIMING_SOURCE_SELF:
|
|
drv_vi_pattern->timing_source = EXT_VI_PATTERN_TIMING_SOURCE_SELF;
|
|
break;
|
|
default:
|
|
mpi_vi_log_err("not support timing source : %d\n", iapi_vi_pattern->timing_source);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
switch (iapi_vi_pattern->data) {
|
|
case UAPI_VI_PATTERN_DATA_OFF:
|
|
drv_vi_pattern->data = EXT_VI_PATTERN_DATA_OFF;
|
|
break;
|
|
case UAPI_VI_PATTERN_DATA_STATIC:
|
|
drv_vi_pattern->data = EXT_VI_PATTERN_DATA_STATIC;
|
|
break;
|
|
case UAPI_VI_PATTERN_DATA_DYNAMIC:
|
|
drv_vi_pattern->data = EXT_VI_PATTERN_DATA_DYNAMIC;
|
|
break;
|
|
case UAPI_VI_PATTERN_DATA_MAX:
|
|
drv_vi_pattern->data = EXT_VI_PATTERN_DATA_MAX;
|
|
break;
|
|
default:
|
|
mpi_vi_log_err("not support data : %d\n", iapi_vi_pattern->data);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_vi_pattern(const ext_vi_pattern_info *drv_vi_pattern,
|
|
uapi_vi_pattern_info *iapi_vi_pattern)
|
|
{
|
|
if (drv_vi_pattern == TD_NULL || iapi_vi_pattern == TD_NULL) {
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
switch (drv_vi_pattern->timing_source) {
|
|
case EXT_VI_PATTERN_TIMING_SOURCE_OFF:
|
|
iapi_vi_pattern->timing_source = UAPI_VI_PATTERN_TIMING_SOURCE_OFF;
|
|
break;
|
|
case EXT_VI_PATTERN_TIMING_SOURCE_INPUT:
|
|
iapi_vi_pattern->timing_source = UAPI_VI_PATTERN_TIMING_SOURCE_INPUT;
|
|
break;
|
|
case EXT_VI_PATTERN_TIMING_SOURCE_SELF:
|
|
iapi_vi_pattern->timing_source = UAPI_VI_PATTERN_TIMING_SOURCE_SELF;
|
|
break;
|
|
default:
|
|
mpi_vi_log_err("not support timing source : %d\n", drv_vi_pattern->timing_source);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
switch (drv_vi_pattern->data) {
|
|
case EXT_VI_PATTERN_DATA_OFF:
|
|
iapi_vi_pattern->data = UAPI_VI_PATTERN_DATA_OFF;
|
|
break;
|
|
case EXT_VI_PATTERN_DATA_STATIC:
|
|
iapi_vi_pattern->data = UAPI_VI_PATTERN_DATA_STATIC;
|
|
break;
|
|
case EXT_VI_PATTERN_DATA_DYNAMIC:
|
|
iapi_vi_pattern->data = UAPI_VI_PATTERN_DATA_DYNAMIC;
|
|
break;
|
|
case EXT_VI_PATTERN_DATA_MAX:
|
|
iapi_vi_pattern->data = UAPI_VI_PATTERN_DATA_MAX;
|
|
break;
|
|
default:
|
|
mpi_vi_log_err("not support data : %d\n", drv_vi_pattern->data);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_frame_addr(const ext_drv_vid_frame_addr *drv_frame_addr,
|
|
uapi_video_frame_addr *iapi_frame_addr)
|
|
{
|
|
if (drv_frame_addr == TD_NULL || iapi_frame_addr == TD_NULL) {
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
iapi_frame_addr->start_addr = drv_frame_addr->start_addr;
|
|
iapi_frame_addr->y_head_offset = drv_frame_addr->y_head_offset;
|
|
iapi_frame_addr->y_offset = drv_frame_addr->y_offset;
|
|
iapi_frame_addr->c_head_offset = drv_frame_addr->c_head_offset;
|
|
iapi_frame_addr->c_offset = drv_frame_addr->c_offset;
|
|
iapi_frame_addr->cr_head_offset = drv_frame_addr->cr_head_offset;
|
|
iapi_frame_addr->cr_offset = drv_frame_addr->cr_offset;
|
|
iapi_frame_addr->stride_y = drv_frame_addr->stride_y;
|
|
iapi_frame_addr->stride_c = drv_frame_addr->stride_c;
|
|
iapi_frame_addr->stride_cr = drv_frame_addr->stride_cr;
|
|
iapi_frame_addr->head_stride = drv_frame_addr->head_stride;
|
|
iapi_frame_addr->head_size = drv_frame_addr->head_size;
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_video_field_mode(const ext_drv_field_mode drv_display_field_mode,
|
|
uapi_video_field_mode *iapi_display_field_mode)
|
|
{
|
|
switch (drv_display_field_mode) {
|
|
case EXT_DRV_FIELD_ALL:
|
|
*iapi_display_field_mode = UAPI_VIDEO_FIELD_ALL;
|
|
break;
|
|
|
|
case EXT_DRV_FIELD_TOP:
|
|
*iapi_display_field_mode = UAPI_VIDEO_FIELD_TOP;
|
|
break;
|
|
|
|
case EXT_DRV_FIELD_BOTTOM:
|
|
*iapi_display_field_mode = UAPI_VIDEO_FIELD_BOTTOM;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("not support this dis_play_field_mode[%d]\n", drv_display_field_mode);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
mpi_vi_log_dbg("convert %d to %d\n", drv_display_field_mode, *iapi_display_field_mode);
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_frame_info(const ext_drv_video_frame *drv_frame_info,
|
|
uapi_video_frame_info *iapi_frame_info)
|
|
{
|
|
td_s32 ret;
|
|
memset_s(iapi_frame_info, sizeof(uapi_video_frame_info), 0, sizeof(uapi_video_frame_info));
|
|
|
|
iapi_frame_info->frame_index = drv_frame_info->frame_index;
|
|
ret = mpi_vi_convert_drv_to_iapi_source_type(drv_frame_info->video_private.source, &iapi_frame_info->source_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_bit_depth(drv_frame_info->bit_width, &iapi_frame_info->bit_depth);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_hdr_type(drv_frame_info->hdr_type, &iapi_frame_info->hdr_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_color_description(drv_frame_info->color_space,
|
|
&iapi_frame_info->color_description);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_pix_fmt(drv_frame_info->pixel_format, &iapi_frame_info->video_format);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_scan_type(drv_frame_info->sample_type, &iapi_frame_info->scan_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_video_field_mode(drv_frame_info->field_mode, &iapi_frame_info->field_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_3d_fmt(drv_frame_info->video_3d_type, &iapi_frame_info->frame_packing_type);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_frame_addr(&drv_frame_info->buf_addr[0], &iapi_frame_info->frame_addr[0]);
|
|
if (ret != TD_SUCCESS) {
|
|
return ret;
|
|
}
|
|
|
|
iapi_frame_info->pts = drv_frame_info->pts;
|
|
iapi_frame_info->frame_rate = drv_frame_info->frame_rate;
|
|
iapi_frame_info->compress_info.compress_mode = UAPI_VIDEO_COMPRESS_OFF;
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_frame_info(const uapi_video_frame_info *iapi_frame_info,
|
|
ext_drv_video_frame *drv_frame_info)
|
|
{
|
|
drv_frame_info->buf_addr[0].start_addr = iapi_frame_info->frame_addr[0].start_addr;
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_drv_to_iapi_output_attr(const ext_vi_output_attr *drv_output_attr,
|
|
uapi_vi_output_attr *iapi_output_attr)
|
|
{
|
|
iapi_output_attr->frame_rate = drv_output_attr->frame_rate;
|
|
iapi_output_attr->width = drv_output_attr->width;
|
|
iapi_output_attr->height = drv_output_attr->height;
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 mpi_vi_convert_iapi_to_drv_output_attr(const uapi_vi_output_attr *iapi_output_attr,
|
|
ext_vi_output_attr *drv_output_attr)
|
|
{
|
|
drv_output_attr->frame_rate = iapi_output_attr->frame_rate;
|
|
drv_output_attr->width = iapi_output_attr->width;
|
|
drv_output_attr->height = iapi_output_attr->height;
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_init(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_init();
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_init faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_deinit(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_deinit();
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_deinit faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_get_default_attr(uapi_vi_attr *attr)
|
|
{
|
|
mpi_vi_func_enter();
|
|
|
|
if (attr == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
attr->vi_type = UAPI_VI_MAIN;
|
|
attr->intf_mode = UAPI_VI_INTF_FVHDE;
|
|
|
|
attr->source_type = UAPI_VIDEO_SOURCE_HDMI;
|
|
attr->access_type = UAPI_VI_ACCESS_HDMIRX_PORT0;
|
|
|
|
attr->over_sample = UAPI_OVERSAMPLE_1X;
|
|
attr->video_3d_type = UAPI_FRAME_PACKING_TYPE_2D;
|
|
attr->bit_depth = UAPI_PIXEL_BIT_DEPTH_10BIT;
|
|
attr->pixel_format = UAPI_FORMAT_YUV_SEMIPLANAR_444_VU;
|
|
attr->picture_mode = UAPI_VI_PICTURE_MODE_VIDEO;
|
|
attr->vblank = 0;
|
|
attr->secure = TD_FALSE;
|
|
|
|
attr->color_description.color_primary = UAPI_COLOR_PRIMARY_BT709;
|
|
attr->color_description.color_space = UAPI_COLOR_CS_YUV;
|
|
attr->color_description.quantify_range = UAPI_COLOR_FULL_RANGE;
|
|
attr->color_description.transfer_type = UAPI_COLOR_TRANSFER_TYPE_GAMMA_SDR;
|
|
attr->color_description.matrix_coef = UAPI_COLOR_MATRIX_COEFFS_BT709;
|
|
|
|
attr->vi_config.interlace = TD_FALSE;
|
|
attr->vi_config.width = 1920; /* 1920 is default width */
|
|
attr->vi_config.height = 1080; /* 1080 is default height */
|
|
attr->vi_config.frame_rate = 30; /* 30 is default rate */
|
|
attr->vi_config.input_rect.x = 0;
|
|
attr->vi_config.input_rect.y = 0;
|
|
attr->vi_config.input_rect.width = attr->vi_config.width;
|
|
attr->vi_config.input_rect.height = attr->vi_config.height;
|
|
attr->vi_config.color_sys = UAPI_COLOR_SYS_AUTO;
|
|
attr->vi_config.display_field = UAPI_VI_DISPLAY_FIELD_ALL;
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_create(uapi_vi_attr *attr, td_handle *vi_handle)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_attr drv_attr = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
if (attr == TD_NULL || vi_handle == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_vi_attr(attr, &drv_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_iapi_to_drv_vi_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = ext_mpi_vi_create(&drv_attr, vi_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_create faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_destroy(td_handle vi_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_destroy(vi_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_destroy faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_attach_win(td_handle vi_handle, td_handle win_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_attach(vi_handle, win_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("uapi_vi_attach_win faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_detach_win(td_handle vi_handle, td_handle win_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_detach(vi_handle, win_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("uapi_vi_detach_win faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_start(td_handle vi_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_start(vi_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_start faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_stop(td_handle vi_handle)
|
|
{
|
|
td_s32 ret;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_stop(vi_handle);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_stop faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_update_nstd_info(td_handle vi_handle, uapi_video_nonstd_info *info)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_nonstd_info drv_nstd_info = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
if (info == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
drv_nstd_info.non_std = info->is_non_std;
|
|
drv_nstd_info.height = info->height;
|
|
drv_nstd_info.v_freq = info->v_freq;
|
|
|
|
ret = ext_mpi_vi_update_nstd_info(vi_handle, drv_nstd_info);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_update_nstd_info faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_set_src_quantization_range(td_handle vi_handle, uapi_vi_quantization_range range_type)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_quantization_range drv_range_type;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
switch (range_type) {
|
|
case UAPI_VI_QUANTIZATION_RANGE_AUTO:
|
|
drv_range_type = EXT_VI_QUANTIZATION_RANGE_AUTO;
|
|
break;
|
|
|
|
case UAPI_VI_QUANTIZATION_RANGE_FULL:
|
|
drv_range_type = EXT_VI_QUANTIZATION_RANGE_FULL;
|
|
break;
|
|
|
|
case UAPI_VI_QUANTIZATION_RANGE_LIMIT:
|
|
drv_range_type = EXT_VI_QUANTIZATION_RANGE_LIMIT;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("wrong csc type in setting vi!\n");
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
ret = ext_mpi_vi_set_src_quantization_range(vi_handle, drv_range_type);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_set_src_quantization_range faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_set_picture_mode(td_handle vi_handle, uapi_vi_picture_mode picture_mode)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_picture_mode drv_picture_mode;
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
switch (picture_mode) {
|
|
case UAPI_VI_PICTURE_MODE_VIDEO:
|
|
drv_picture_mode = EXT_VI_PICTURE_MODE_VIDEO;
|
|
break;
|
|
|
|
case UAPI_VI_PICTURE_MODE_PC:
|
|
drv_picture_mode = EXT_VI_PICTURE_MODE_PC;
|
|
break;
|
|
|
|
case UAPI_VI_PICTURE_MODE_GAME:
|
|
drv_picture_mode = EXT_VI_PICTURE_MODE_GAME;
|
|
break;
|
|
|
|
default:
|
|
mpi_vi_log_err("wrong picture mode in setting vi!\n");
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
ret = ext_mpi_vi_set_picture_mode(vi_handle, drv_picture_mode);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_set_picture_mode faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_set_config(td_handle vi_handle, const uapi_vi_config *cfg)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_config drv_cfg = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_vi_config(cfg, &drv_cfg);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_iapi_to_drv_vi_config faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = ext_mpi_vi_set_config(vi_handle, &drv_cfg);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_set_config faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_get_config(td_handle vi_handle, uapi_vi_config *cfg)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_config drv_cfg = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_get_config(vi_handle, &drv_cfg);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_get_config faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_vi_config(&drv_cfg, cfg);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_drv_to_iapi_vi_config faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_get_attr(td_handle vi_handle, uapi_vi_attr *attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_attr drv_attr = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
if (attr == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
ret = ext_mpi_vi_get_attr(vi_handle, &drv_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_get_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_vi_attr(&drv_attr, attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_drv_to_iapi_vi_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_set_capture_latency(td_handle vi_handle, td_u32 capture_latency)
|
|
{
|
|
td_s32 ret;
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_set_capture_latency(vi_handle, capture_latency);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("uapi_vi_set_frame_latency_threshold faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
|
|
td_s32 uapi_vi_get_capture_latency(td_handle vi_handle, td_u32 *capture_latency)
|
|
{
|
|
td_s32 ret;
|
|
mpi_vi_func_enter();
|
|
|
|
ret = ext_mpi_vi_get_capture_latency(vi_handle, capture_latency);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("uapi_vi_set_frame_latency_threshold faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_set_pattern(td_handle vi_handle, uapi_vi_pattern_info *pattern_info)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_pattern_info drv_pattern = {0};
|
|
mpi_vi_func_enter();
|
|
|
|
if (pattern_info == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_vi_pattern(pattern_info, &drv_pattern);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_drv_to_iapi_vi_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = ext_mpi_vi_set_pattern(vi_handle, &drv_pattern);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_set_pattern faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_get_pattern(td_handle vi_handle, uapi_vi_pattern_info *pattern_info)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_pattern_info drv_pattern = {0};
|
|
mpi_vi_func_enter();
|
|
|
|
if (pattern_info == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
ret = ext_mpi_vi_get_pattern(vi_handle, &drv_pattern);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_set_pattern faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_vi_pattern(&drv_pattern, pattern_info);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_drv_to_iapi_vi_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
mpi_vi_log_info("timing source: %d, data: %d\n", pattern_info->timing_source, pattern_info->data);
|
|
mpi_vi_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_acquire_frame(td_handle vi_handle, uapi_video_frame_info *frame_info, td_u32 timeout_ms)
|
|
{
|
|
vi_path_info path_info = {0};
|
|
path_info.vi_handle = vi_handle;
|
|
td_s32 ret = TD_FAILURE;
|
|
td_u32 delay_time_ms = TIMEOUT_MAX_VALUE_MS;
|
|
struct timeval time_thread_start = {0};
|
|
struct timeval time_thread_end = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
if (timeout_ms > TIMEOUT_MAX_VALUE_MS) {
|
|
mpi_vi_log_err("timeout_ms:%u too big!\n", timeout_ms);
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
gettimeofday(&time_thread_start, NULL);
|
|
do {
|
|
ret = ext_mpi_vi_acquire_frame(&path_info);
|
|
if (ret == TD_SUCCESS) {
|
|
break;
|
|
}
|
|
gettimeofday(&time_thread_end, NULL);
|
|
delay_time_ms = mpi_vi_diff_us(time_thread_end, time_thread_start) / 1000; /* 1000:us convert to ms */
|
|
} while (delay_time_ms <= timeout_ms);
|
|
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_dbg("acquire fail.\n");
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_frame_info(&path_info.video_frame, frame_info);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("convert frame info fail, ret=0x%x!\n", ret);
|
|
path_info.video_frame.sink_fence = -1; // uapi don't use fence
|
|
ret = ext_mpi_vi_release_frame(&path_info);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("release frame fail, ret=0x%x!\n", ret);
|
|
}
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_vi_release_frame(td_handle vi_handle, uapi_video_frame_info *frame_info)
|
|
{
|
|
vi_path_info path_info = {0};
|
|
path_info.vi_handle = vi_handle;
|
|
td_s32 ret = TD_FAILURE;
|
|
mpi_vi_func_enter();
|
|
|
|
if (frame_info == TD_NULL) {
|
|
mpi_vi_log_err("frame_info is null!\n");
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_frame_info(frame_info, &path_info.video_frame);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("convert frame info fail!\n");
|
|
return SOC_ERR_VI_INVALID_PARA;
|
|
}
|
|
|
|
path_info.video_frame.sink_fence = -1; // uapi don't use fence
|
|
ret = ext_mpi_vi_release_frame(&path_info);
|
|
mpi_vi_func_exit();
|
|
return ret;
|
|
}
|
|
|
|
td_s32 uapi_vi_set_output_attr(td_handle vi_handle, const uapi_vi_output_attr *output_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_output_attr ext_output_attr = {0};
|
|
mpi_vi_func_enter();
|
|
|
|
if (output_attr == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
ret = mpi_vi_convert_iapi_to_drv_output_attr(output_attr, &ext_output_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_iapi_to_drv_output_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = ext_mpi_vi_set_output_attr(vi_handle, &ext_output_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_set_output_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
td_s32 uapi_vi_get_output_attr(td_handle vi_handle, uapi_vi_output_attr *output_attr)
|
|
{
|
|
td_s32 ret;
|
|
ext_vi_output_attr ext_output_attr = {0};
|
|
|
|
mpi_vi_func_enter();
|
|
|
|
if (output_attr == TD_NULL) {
|
|
mpi_vi_log_err("PTR is NULL.\n");
|
|
return SOC_ERR_VI_NULL_PTR;
|
|
}
|
|
|
|
ret = ext_mpi_vi_get_output_attr(vi_handle, &ext_output_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("ext_mpi_vi_get_output_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
ret = mpi_vi_convert_drv_to_iapi_output_attr(&ext_output_attr, output_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
mpi_vi_log_err("mpi_vi_convert_drv_to_iapi_output_attr faild, ret is 0x%x.\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
mpi_vi_func_exit();
|
|
return TD_SUCCESS;
|
|
}
|
|
|