419 lines
14 KiB
C
419 lines
14 KiB
C
/*
|
|
Copyright (c), 2001-2022, Shenshu Tech. Co., Ltd.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "securec.h"
|
|
#include "ot_type.h"
|
|
#include "ot_common.h"
|
|
#include "ot_common_video.h"
|
|
#include "ot_math.h"
|
|
#include "ot_common_vpss.h"
|
|
#include "ss_mpi_vpss.h"
|
|
|
|
#define MAX_PARA_NAME_LEN 16
|
|
|
|
static td_char g_para[MAX_PARA_NAME_LEN];
|
|
static td_u32 g_value;
|
|
static ot_vpss_grp g_vpss_grp;
|
|
static ot_vpss_grp g_vpss_chn;
|
|
|
|
static ot_vpss_grp_attr g_grp_attr;
|
|
static ot_vpss_grp_param g_grp_param;
|
|
static ot_vpss_nrx_adv_param g_nrx_adv_param;
|
|
static ot_vpss_chn_sharpen_param g_sharpen_param;
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
static ot_vpss_ldci_attr g_ldci_attr;
|
|
#endif
|
|
|
|
static td_bool g_is_set_chn;
|
|
|
|
static td_void usage(td_void)
|
|
{
|
|
printf("\n\tusage : ./vpss_attr para value group [chn] \n");
|
|
printf("\n\texample 1 : set dci strength 60 to group 1 -- ./vpss_attr con 60 1 \n");
|
|
printf("\n\texample 2 : set sharpen strength 50 to group 1 chn 2 -- ./vpss_attr chnsp 50 1 2\n");
|
|
printf("\n\tpara: \n");
|
|
printf("\t\tie_en [0, disable; 1, enable]\n");
|
|
printf("\t\tnr_en [0, disable; 1, enable]\n");
|
|
printf("\t\tdei_en [0, nodei; 1, dei; 2, auto]\n");
|
|
printf("\t\tdci_en [0, disable; 1, enable]\n");
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
printf("\t\tldci_en [0, disable; 1, enable]\n");
|
|
#endif
|
|
printf("\t\tcon [strength of dynamic contrast improve, value:0~63, default:8]\n");
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
printf("\t\tblc [restrain dark region, value:0~511, default:50]\n");
|
|
printf("\t\tpos_w [weight of Gaussian distribution for the degree of brightening, value:0~255, default:40]\n");
|
|
printf("\t\tpos_s [sigma of Gaussian distribution for the degree of brightening, value:1~255, default:72]\n");
|
|
printf("\t\tpos_m [mean of Gaussian distribution for the degree of brightening, value:0~255, default:0]\n");
|
|
printf("\t\tneg_w [weight of Gaussian distribution for the degree of darkening, value:0~255, default:45]\n");
|
|
printf("\t\tneg_s [sigma of Gaussian distribution for the degree of darkening, value:1~255, default:80]\n");
|
|
printf("\t\tneg_m [mean of Gaussian distribution for the degree of darkening, value:0~255, default:128]\n");
|
|
#endif
|
|
printf("\t\tie [strength of image enhance, value:0~63, default:4]\n");
|
|
printf("\t\tsf [strength of y space filter, value:0~255, default:24]\n");
|
|
printf("\t\ttf [strength of y time filter, value:0~63, default:12]\n");
|
|
printf("\t\tcsf [strength of c space filter, value:0~255, default:12]\n");
|
|
printf("\t\tctf [strength of c time filter, value:0~32, default:16]\n");
|
|
printf("\t\tcvbs [strength of cvbs output, value:0~32, default:24]\n");
|
|
printf("\t\tmdz [threshold of motion, value:0~63, default:6]\n");
|
|
printf("\t\tedz [threshold of strong edge, value:0~63, default:63]\n");
|
|
printf("\t\thtfr [relation strength of hard nr chn, value:0~96, default:52]\n");
|
|
printf("\t\twtfr [relation strength of weak nr chn, value:0~63, default:36]\n");
|
|
printf("\t\tsp_en [0, disable; 1, enable]\n");
|
|
printf("\t\tchnsp [sp strength of chn, value:0~100, default:0]\n");
|
|
}
|
|
|
|
static __inline__ td_bool vpss_attr_is_the_same_string(const td_char *left, const td_char *right)
|
|
{
|
|
if ((left == TD_NULL) || (right == TD_NULL)) {
|
|
return TD_FALSE;
|
|
}
|
|
return ((strlen(left) == strlen(right)) && (strncmp(left, right, strlen(right)) == 0));
|
|
}
|
|
|
|
static td_void vpss_attr_init_input(td_void)
|
|
{
|
|
(td_void)memset_s(g_para, sizeof(g_para), 0, sizeof(g_para));
|
|
g_value = 0;
|
|
g_vpss_grp = -1;
|
|
g_vpss_chn = -1;
|
|
}
|
|
|
|
static td_s32 vpss_attr_parse_input_para(td_s32 argc, td_char *argv[])
|
|
{
|
|
if ((argc < 4) || (argc > 5)) { /* The number of parameters should be [4, 5] */
|
|
printf("\n\t\033[0;31m!!!!!!!!!!!!!err para!!!!!!!!!!!!!\033[0;39m\n");
|
|
usage();
|
|
return OT_ERR_VPSS_ILLEGAL_PARAM;
|
|
}
|
|
|
|
vpss_attr_init_input();
|
|
|
|
if (strncpy_s(g_para, MAX_PARA_NAME_LEN, argv[1], MAX_PARA_NAME_LEN - 1) != EOK) { /* 1: para */
|
|
printf("get para failed!\n");
|
|
return OT_ERR_VPSS_ILLEGAL_PARAM;
|
|
}
|
|
|
|
g_value = (td_u32)atoi(argv[2]); /* 2: value */
|
|
|
|
g_vpss_grp = atoi(argv[3]); /* 3: grp */
|
|
if (!value_between(g_vpss_grp, 0, OT_VPSS_MAX_GRP_NUM - 1)) {
|
|
printf("grp must be [0,%d]!\n", OT_VPSS_MAX_GRP_NUM - 1);
|
|
return OT_ERR_VPSS_ILLEGAL_PARAM;
|
|
}
|
|
|
|
if (argc == 5) { /* 5: for chn */
|
|
g_vpss_chn = atoi(argv[4]); /* 4: chn */
|
|
if (!value_between(g_vpss_chn, 0, OT_VPSS_MAX_CHN_NUM - 1)) {
|
|
printf("chn must be [0,%d]!\n", OT_VPSS_MAX_CHN_NUM - 1);
|
|
return OT_ERR_VPSS_ILLEGAL_PARAM;
|
|
}
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 vpss_attr_init_config(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
g_is_set_chn = TD_FALSE;
|
|
|
|
ret = ss_mpi_vpss_get_grp_attr(g_vpss_grp, &g_grp_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_get_grp_attr failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
|
|
ret = ss_mpi_vpss_get_grp_param(g_vpss_grp, &g_grp_param);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_get_grp_param failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
|
|
ret = ss_mpi_vpss_get_grp_nrx_adv_param(g_vpss_grp, &g_nrx_adv_param);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_get_grp_nrx_adv_param failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
ret = ss_mpi_vpss_get_ldci_attr(g_vpss_grp, &g_ldci_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_get_ldci_attr failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
if (g_vpss_chn != -1) {
|
|
ret = ss_mpi_vpss_get_chn_sharpen(g_vpss_grp, g_vpss_chn, &g_sharpen_param);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_get_chn_sharpen failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_s32 vpss_attr_set_config(td_void)
|
|
{
|
|
td_s32 ret;
|
|
|
|
ret = ss_mpi_vpss_set_grp_attr(g_vpss_grp, &g_grp_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_set_grp_attr failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
|
|
ret = ss_mpi_vpss_set_grp_param(g_vpss_grp, &g_grp_param);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_set_grp_param failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
|
|
ret = ss_mpi_vpss_set_grp_nrx_adv_param(g_vpss_grp, &g_nrx_adv_param);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_set_grp_nrx_adv_param failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
ret = ss_mpi_vpss_set_ldci_attr(g_vpss_grp, &g_ldci_attr);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_set_ldci_attr failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
if (g_is_set_chn == TD_TRUE) {
|
|
ret = ss_mpi_vpss_set_chn_sharpen(g_vpss_grp, g_vpss_chn, &g_sharpen_param);
|
|
if (ret != TD_SUCCESS) {
|
|
printf("ss_mpi_vpss_set_chn_sharpen failed at %s: LINE: %d!\n", __FUNCTION__, __LINE__);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|
|
static td_bool vpss_attr_config_ie(const td_char *para)
|
|
{
|
|
if (vpss_attr_is_the_same_string(para, "ie_en")) {
|
|
g_grp_attr.ie_en = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "ie")) {
|
|
g_grp_param.ie_strength = g_value;
|
|
return TD_TRUE;
|
|
} else {
|
|
return TD_FALSE;
|
|
}
|
|
}
|
|
|
|
static td_bool vpss_attr_config_nr(const td_char *para)
|
|
{
|
|
if (vpss_attr_is_the_same_string(para, "nr_en")) {
|
|
g_grp_attr.nr_en = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "sf")) {
|
|
g_grp_param.nrx_param.nrx_norm_param_v1.sf_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "tf")) {
|
|
g_grp_param.nrx_param.nrx_norm_param_v1.tf_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "csf")) {
|
|
g_grp_param.nrx_param.nrx_norm_param_v1.csf_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "ctf")) {
|
|
g_grp_param.nrx_param.nrx_norm_param_v1.ctf_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "cvbs")) {
|
|
g_grp_param.nrx_param.nrx_norm_param_v1.cvbs_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "mdz")) {
|
|
g_nrx_adv_param.mdz = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "edz")) {
|
|
g_nrx_adv_param.edz = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "htfr")) {
|
|
g_nrx_adv_param.hard_tf_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "wtfr")) {
|
|
g_nrx_adv_param.weak_tf_strength = g_value;
|
|
return TD_TRUE;
|
|
} else {
|
|
return TD_FALSE;
|
|
}
|
|
}
|
|
|
|
static td_bool vpss_attr_config_dei(const td_char *para)
|
|
{
|
|
if (vpss_attr_is_the_same_string(para, "dei_en")) {
|
|
g_grp_attr.dei_mode = (ot_vpss_dei_mode)g_value;
|
|
return TD_TRUE;
|
|
} else {
|
|
return TD_FALSE;
|
|
}
|
|
}
|
|
|
|
static td_bool vpss_attr_config_dci(const td_char *para)
|
|
{
|
|
if (vpss_attr_is_the_same_string(para, "dci_en")) {
|
|
g_grp_attr.dci_en = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "con")) {
|
|
g_grp_param.contrast = g_value;
|
|
return TD_TRUE;
|
|
} else {
|
|
return TD_FALSE;
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
static td_bool vpss_attr_config_ldci(const td_char *para)
|
|
{
|
|
if (vpss_attr_is_the_same_string(para, "ldci_en")) {
|
|
g_ldci_attr.enable = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "blc")) {
|
|
g_ldci_attr.black_ctrl_strength = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "pos_w")) {
|
|
g_ldci_attr.he_weight_attr.positive_attr.weight = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "pos_s")) {
|
|
g_ldci_attr.he_weight_attr.positive_attr.sigma = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "pos_m")) {
|
|
g_ldci_attr.he_weight_attr.positive_attr.mean = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "neg_w")) {
|
|
g_ldci_attr.he_weight_attr.negative_attr.weight = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "neg_s")) {
|
|
g_ldci_attr.he_weight_attr.negative_attr.sigma = g_value;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "neg_m")) {
|
|
g_ldci_attr.he_weight_attr.negative_attr.mean = g_value;
|
|
return TD_TRUE;
|
|
} else {
|
|
return TD_FALSE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static td_bool vpss_attr_config_sharpen(const td_char *para)
|
|
{
|
|
if (vpss_attr_is_the_same_string(para, "sp_en")) {
|
|
g_sharpen_param.enable = g_value;
|
|
g_is_set_chn = TD_TRUE;
|
|
return TD_TRUE;
|
|
} else if (vpss_attr_is_the_same_string(para, "chnsp")) {
|
|
g_sharpen_param.strength = g_value;
|
|
g_is_set_chn = TD_TRUE;
|
|
return TD_TRUE;
|
|
} else {
|
|
return TD_FALSE;
|
|
}
|
|
}
|
|
|
|
static td_s32 vpss_attr_do_config(td_void)
|
|
{
|
|
const td_char *para = g_para;
|
|
|
|
if (vpss_attr_config_ie(para)) {
|
|
return TD_SUCCESS;
|
|
} else if (vpss_attr_config_nr(para)) {
|
|
return TD_SUCCESS;
|
|
} else if (vpss_attr_config_dei(para)) {
|
|
return TD_SUCCESS;
|
|
} else if (vpss_attr_config_dci(para)) {
|
|
return TD_SUCCESS;
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
} else if (vpss_attr_config_ldci(para)) {
|
|
return TD_SUCCESS;
|
|
#endif
|
|
} else if (vpss_attr_config_sharpen(para)) {
|
|
return TD_SUCCESS;
|
|
} else {
|
|
printf("\n\t\033[0;31m!!!!!!!!!!!!!err para!!!!!!!!!!!!!\033[0;39m\n");
|
|
usage();
|
|
return TD_FAILURE;
|
|
}
|
|
}
|
|
|
|
static td_void vpss_attr_print_config(td_void)
|
|
{
|
|
printf("\t\tie_en %d\n", g_grp_attr.ie_en);
|
|
printf("\t\tnr_en %d\n", g_grp_attr.nr_en);
|
|
printf("\t\tdei_en %d\n", g_grp_attr.dei_mode);
|
|
printf("\t\tdci_en %d\n", g_grp_attr.dci_en);
|
|
|
|
#ifdef CONFIG_OT_VPSS_LDCI_SUPPORT
|
|
printf("\t\tldci_en %d\n", g_ldci_attr.enable);
|
|
printf("\t\tblc %u\n", g_ldci_attr.black_ctrl_strength);
|
|
printf("\t\tpos_w %u\n", g_ldci_attr.he_weight_attr.positive_attr.weight);
|
|
printf("\t\tpos_s %u\n", g_ldci_attr.he_weight_attr.positive_attr.sigma);
|
|
printf("\t\tpos_m %u\n", g_ldci_attr.he_weight_attr.positive_attr.mean);
|
|
printf("\t\tneg_w %u\n", g_ldci_attr.he_weight_attr.negative_attr.weight);
|
|
printf("\t\tneg_s %u\n", g_ldci_attr.he_weight_attr.negative_attr.sigma);
|
|
printf("\t\tneg_m %u\n", g_ldci_attr.he_weight_attr.negative_attr.mean);
|
|
#endif
|
|
|
|
printf("\t\tcon %u\n", g_grp_param.contrast);
|
|
printf("\t\tie %u\n", g_grp_param.ie_strength);
|
|
printf("\t\tsf %u\n", g_grp_param.nrx_param.nrx_norm_param_v1.sf_strength);
|
|
printf("\t\ttf %u\n", g_grp_param.nrx_param.nrx_norm_param_v1.tf_strength);
|
|
printf("\t\tcsf %u\n", g_grp_param.nrx_param.nrx_norm_param_v1.csf_strength);
|
|
printf("\t\tctf %u\n", g_grp_param.nrx_param.nrx_norm_param_v1.ctf_strength);
|
|
printf("\t\tcvbs %u\n", g_grp_param.nrx_param.nrx_norm_param_v1.cvbs_strength);
|
|
|
|
printf("\t\tmdz %u\n", g_nrx_adv_param.mdz);
|
|
printf("\t\tedz %u\n", g_nrx_adv_param.edz);
|
|
printf("\t\thtfr %u\n", g_nrx_adv_param.hard_tf_strength);
|
|
printf("\t\twtfr %u\n", g_nrx_adv_param.weak_tf_strength);
|
|
|
|
printf("\t\tsp_en %d\n", g_sharpen_param.enable);
|
|
printf("\t\tchnsp %u\n", g_sharpen_param.strength);
|
|
}
|
|
|
|
#ifdef __LITEOS__
|
|
td_s32 vpss_attr(int argc, char *argv[])
|
|
#else
|
|
td_s32 main(int argc, char *argv[])
|
|
#endif
|
|
{
|
|
td_s32 ret;
|
|
|
|
ret = vpss_attr_parse_input_para(argc, argv);
|
|
if (ret != TD_SUCCESS) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = vpss_attr_init_config();
|
|
if (ret != TD_SUCCESS) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = vpss_attr_do_config();
|
|
if (ret != TD_SUCCESS) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
ret = vpss_attr_set_config();
|
|
if (ret != TD_SUCCESS) {
|
|
return TD_FAILURE;
|
|
}
|
|
|
|
vpss_attr_print_config();
|
|
|
|
return TD_SUCCESS;
|
|
}
|
|
|