/*
  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;
}